 --======================================================================--

--======================================================================--
local 系统处理类 = class()
function 系统处理类:初始化() end
function 系统处理类:数据处理(id,序号,内容)

  -- __S服务:输出("开始加载科举题库"..id.."##"..序号)
  if 内容.ip~=nil and f函数.读配置(程序目录 .. "ip封禁.ini", "ip", 内容.ip)=="1" or f函数.读配置(程序目录 .. "ip封禁.ini", "ip", 内容.ip)==1 then
      __S服务:输出(string.format("封禁ip的客户进入试图进入(%s):%s:%s", 内容.id, 内容.ip,id))
      发送数据(id,7,"您的已被禁止登陆!")
      return 0
  end
  if 序号==1 or 序号==1.1 or 序号==1.2 then
    self:账号验证(id,序号,内容)
  elseif 序号==2 then -- 申请创建角色
    if f函数.文件是否存在([[data/]]..内容.账号)==false then  --未创建存档
      发送数据(id,3)
    else
      self.临时文件=读入文件([[data/]]..内容.账号..[[/信息.txt]])
      self.写入信息=table.loadstring(self.临时文件)
      if #self.写入信息>=6 then
        发送数据(id,7,"#Y/您无法再创建更多的角色了")
        return 0
      end
      发送数据(id,3)
    end
  elseif 序号==3 then --创建新角色
    for n=1,#名称数据 do
      if 名称数据[n].名称==内容.名称 then
        发送数据(id,7,"#Y/这个名称已经被他人占用了，请重新再想个吧")
        return 0
      end
    end
      if f函数.文件是否存在([[data/]]..内容.账号)==false then  --未创建存档
        --创建新的账号数据
        if lfs.mkdir([[data/]]..内容.账号)==false then
          发送数据(id,7,"#Y/建立存档失败，错误代号1001")
          return 0
        end
        --self.写入数据=[[]]
        写出文件([[data/]]..内容.账号..[[/账号信息.txt]],"")
        临时角色=角色处理类.创建()
        临时角色:创建角色(id,内容.账号,内容.模型,内容.名称,内容.ip,内容.染色ID)
         写出文件([[tysj/名称数据.txt]],table.tostring(名称数据))
        临时角色=nil
        self:取角色选择信息(id,内容.账号)
      else
        self.临时文件=读入文件([[data/]]..内容.账号..[[/信息.txt]])
        self.写入信息=table.loadstring(self.临时文件)
        if #self.写入信息>=6 then
          发送数据(id,7,"#Y/您无法再创建更多的角色了")
          return 0
        end
        临时角色=角色处理类.创建()
        临时角色:创建角色(id,内容.账号,内容.模型,内容.名称,内容.ip,内容.染色ID)
        写出文件([[tysj/名称数据.txt]],table.tostring(名称数据))
        临时角色=nil
        self:取角色选择信息(id,内容.账号)
        -- self.临时数据=读入文件()
        -- 服务端参数.id=服务端参数.id+1
      end
  elseif 序号==4 then --选择角色进入游戏
    self:进入游戏(id,内容.账号,内容.id,内容.ip)
  elseif 序号==4.1 or 序号==4.2 then --选择角色进入游戏
    self:进入游戏(id,内容.账号,内容.id,内容.ip,序号)
  elseif 序号==5 then --选择角色进入游戏
    self:断开游戏(内容+0)
  elseif 序号==6 then
    if 玩家数据[内容.数字id].角色.数据.宠物.领养次数==0 then
      玩家数据[内容.数字id].角色.数据.宠物={模型=内容.cw,名称=内容.cw,等级=1,最大等级=120,耐力=5,最大耐力=5,经验=1,最大经验=10,领养次数=1}
      发送数据(id,7,"#Y/领养宠物成功")
      发送数据(id,8,玩家数据[内容.数字id].角色.数据.宠物)
    else
      发送数据(id,7,"#Y/您当前无法再领取宠物了")
    end
  elseif 序号==7 then
   发送数据(id,10,玩家数据[内容.数字id].角色:取总数据())
  elseif 序号==8 then
    玩家数据[内容.数字id].角色:添加属性点(内容,id)
    发送数据(id,10,玩家数据[内容.数字id].角色:取总数据())
  elseif 序号==9 then
    if 玩家数据[内容.数字id].角色.数据.等级>=服务端参数.服务器上限 then
        发送数据(id,7,"#Y/您当前等级已达到服务器上限，等待GM开放更高等级")
        return 0
    end
    玩家数据[内容.数字id].角色:升级处理(id)
  elseif 序号==10 then
    玩家数据[内容.数字id].角色:获取任务信息(id)
  elseif 序号==11 then
    玩家数据[内容.数字id].角色:设置快捷技能(内容)
   -- 发送数据(id,10,玩家数据[内容.数字id].角色:取总数据())
  elseif 序号==12 then
    发送数据(id,41,玩家数据[内容.数字id].角色.数据.快捷技能)
  elseif 序号==13 then
    玩家数据[内容.数字id].角色:使用快捷技能(内容.序列)
  elseif 序号==14 then
    local id=内容.数字id
    if 内容.人物~=nil then
      玩家数据[id].角色.数据.修炼.当前=内容.人物
    end
    if 内容.bb~=nil then
      玩家数据[id].角色.数据.bb修炼.当前=内容.bb
    end
    常规提示(id,"#Y/更换修炼类型成功！")
    刷新修炼数据(id)
  elseif 序号==15 then
    local id=内容.数字id
    if 玩家数据[id].角色.数据.自动遇怪 then
      玩家数据[id].角色.数据.自动遇怪=false
      常规提示(id,"#Y/你关闭了自动遇怪功能")
      自动遇怪[id]=nil
    else
      玩家数据[id].角色.数据.自动遇怪=true
      常规提示(id,"#Y/你开启了自动遇怪功能，每隔15秒会自动触发野外场景暗雷战斗。处于自动遇怪模式下人物将无法进行移动、对话操作。如需关闭此功能，再次勾选自动遇怪即可关闭此功能。")
      自动遇怪[id]=os.time()
    end
    发送数据(玩家数据[id].连接id,48,{遇怪=玩家数据[id].角色.数据.自动遇怪})
  elseif 序号==16 then
    if self:取消息数据(内容.数字id,玩家数据[内容.数字id].连接id)==false then
      玩家数据[内容.数字id].角色:取好友数据(内容.数字id,玩家数据[内容.数字id].连接id,50)
    end
  elseif 序号==17 then --添加好友
    local 查找数据=self:查找角色(内容.名称,内容.id)
    if #查找数据==0 then
     常规提示(内容.数字id,"#Y这个角色并不存在或当前没有在线")
     return
    else
      发送数据(玩家数据[内容.数字id].连接id,51,查找数据)
    end
  elseif 序号==18 then --添加好友
    local 查找数据=self:查找角色(内容.名称,内容.id)
    if #查找数据==0 then
      常规提示(内容.数字id,"#Y这个角色并不存在或当前没有在线")
      return
    else
      --发送数据(玩家数据[内容.数字id].连接id,51,查找数据)
      self:添加好友(内容.数字id,玩家数据[内容.数字id].连接id,查找数据[2],内容.类型)
    end
  elseif 序号==19 then --刷新好友数据
    玩家数据[内容.数字id].角色:取好友数据(内容.数字id,玩家数据[内容.数字id].连接id,53)
  elseif 序号==20 then --更新好友数据
    local id=内容.数字id
    local 类型=内容.类型
    local 序列=内容.序列
    --if 玩家数据[好友id]==nil then
    --  常规提示(内容.数字id,"#Y对方当前不在线，无法更新其信息")
    --  return
    if 玩家数据[id].角色.数据.好友数据[类型]==nil then
      常规提示(内容.数字id,"#Y更新失败，你没有这个分类")
      return
    elseif 玩家数据[id].角色.数据.好友数据[类型][序列]==nil then
      常规提示(内容.数字id,"#Y更新失败，你没有这个好友")
      return
    else
      local 好友id=玩家数据[id].角色.数据.好友数据[类型][序列].id
      if 玩家数据[好友id]==nil then
        常规提示(内容.数字id,"#Y对方当前不在线，无法更新其信息")
        return
      else
        玩家数据[id].角色.数据.好友数据[类型][序列].名称=玩家数据[好友id].角色.数据.名称
        玩家数据[id].角色.数据.好友数据[类型][序列].等级=玩家数据[好友id].角色.数据.等级
        玩家数据[id].角色.数据.好友数据[类型][序列].门派=玩家数据[好友id].角色.数据.门派
        玩家数据[id].角色.数据.好友数据[类型][序列].称谓=玩家数据[好友id].角色.数据.称谓
        玩家数据[id].角色.数据.好友数据[类型][序列].帮派=玩家数据[好友id].角色.数据.帮派
        玩家数据[id].角色.数据.好友数据[类型][序列].称谓=玩家数据[好友id].角色.数据.当前称谓
        发送数据(玩家数据[id].连接id,54,{数据=玩家数据[id].角色.数据.好友数据[类型][序列],类型=类型,序列=序列})
      end
    end
  elseif 序号==21 then
    local id=内容.数字id
    local 好友id=内容.id
    if 玩家数据[好友id]==nil then
      常规提示(id,"#Y对方当前不在线，无法添加其为好友")
      return
    else
      self:添加好友(内容.数字id,玩家数据[内容.数字id].连接id,好友id,1)
    end
  elseif 序号==22 then
    local id=内容.数字id
    local 好友id=内容.id
    if 玩家数据[好友id]==nil then
      常规提示(id,"#Y对方当前不在线，无法添加其为好友")
      return
    else
      self:添加好友(内容.数字id,玩家数据[内容.数字id].连接id,好友id,3)
    end
  elseif 序号==23 then --移除好友
    local id=内容.数字id
    local 好友id=内容.id
    local 类型=内容.类型
    local 删除序列=0
    for n=1,#玩家数据[id].角色.数据.好友数据[类型] do
      if 玩家数据[id].角色.数据.好友数据[类型][n].id==好友id then 删除序列=n end
    end
    if 删除序列~=0 then
      table.remove(玩家数据[id].角色.数据.好友数据[类型],删除序列)
      发送数据(玩家数据[id].连接id,52)
      常规提示(id,"#Y删除好友成功！")
      if 类型=="黑名单" then
        删除序列=0
        for n=1,#好友黑名单[id] do
          if 好友黑名单[id][n]==好友id then 删除序列=n end
        end
        if 删除序列~=0 then
          table.remove(好友黑名单[id],删除序列)
        end
      end
    end
  elseif 序号==24 then --请求发送消息
    local id=内容.数字id
    local 好友id=内容.id
    if 消息数据[好友id]==nil then
      消息数据[好友id]={}
    end
    if self:拒收消息检查(好友id,id,id)==false then return  end
    消息数据[好友id][#消息数据[好友id]+1]={名称=玩家数据[id].角色.数据.名称,类型=1,模型=玩家数据[id].角色.数据.模型,内容=内容.内容,id=id,时间=时间转换1(os.time()),等级=玩家数据[id].角色.数据.等级,好友度=self:取好友度(id,好友id)}
    发送数据(玩家数据[id].连接id,55,{信息=玩家数据[id].角色.数据.名称.."   "..时间转换1(os.time()),id=好友id,内容=内容.内容})
    self:更新消息通知(好友id)
  elseif 序号==25 then
    self:取消息数据(内容.数字id,玩家数据[内容.数字id].连接id)
  elseif 序号==26 then
    local 序列=内容.序列
    local id=内容.数字id
    if 玩家数据[id].角色.数据.坐骑列表[序列]==nil then
      常规提示(id,"#Y你没有这样的坐骑")
      return
    else
      玩家数据[id].角色.数据.坐骑=table.loadstring(table.tostring(玩家数据[id].角色.数据.坐骑列表[序列]))
      常规提示(id,"#Y骑乘坐骑成功！")
      玩家数据[id].角色.数据.坐骑隐藏=0
      玩家数据[id].角色:刷新信息(是否,体质,魔力)
      发送数据(玩家数据[id].连接id,60,玩家数据[id].角色.数据.坐骑)
      发送数据(玩家数据[id].连接id,60.1,玩家数据[id].角色.数据.坐骑.修炼.速度修炼[1])
      地图处理类:更新坐骑(id,玩家数据[id].角色.数据.坐骑)
    end
  elseif 序号==26.1 then
    local 序列=内容.序列
    local id=内容.数字id
    if 玩家数据[id].角色.数据.坐骑列表[序列]==nil then
      常规提示(id,"#Y你没有这样的坐骑")
      return
    else
      玩家数据[id].角色.数据.坐骑隐藏=1
      发送数据(玩家数据[id].连接id,60.3,玩家数据[id].角色.数据.坐骑)
      地图处理类:更新坐骑(id,玩家数据[id].角色.数据.坐骑)
    end
  elseif 序号==26.2 then
    local 序列=内容.序列
    local id=内容.数字id
      玩家数据[id].角色.数据.锦衣隐藏=1
      发送数据(玩家数据[id].连接id,60.4,玩家数据[id].角色.数据.锦衣隐藏)
      地图处理类:更新锦衣(id,玩家数据[id].角色:取锦衣数据())
  elseif 序号==26.3 then
    local 序列=内容.序列
    local id=内容.数字id
      玩家数据[id].角色.数据.锦衣隐藏=0
      地图处理类:更新锦衣(id,玩家数据[id].角色:取锦衣数据())
  elseif 序号==26.8 then
    local id=内容.数字id
    发送数据(玩家数据[id].连接id,124,{攻城数据=攻城数据})
  elseif 序号==27 then
    local id=内容.数字id
    玩家数据[id].角色.数据.坐骑=nil
    常规提示(id,"#Y下乘坐骑成功！")
    玩家数据[id].角色:刷新信息(是否,体质,魔力)
    发送数据(玩家数据[id].连接id,60,玩家数据[id].角色.数据.坐骑)
    发送数据(玩家数据[id].连接id,60.1,nil)
    地图处理类:更新坐骑(id,玩家数据[id].角色.数据.坐骑)
  elseif 序号==28 then
    玩家数据[内容.数字id].角色:取快捷技能(内容.数字id)
  elseif 序号==29 then
    if 内容.分类~=nil then
      商城处理类:取商品组数据(内容.数字id, 18,内容.分类)
    else
      商城处理类:取商品组数据(内容.数字id, 18)
    end

  elseif 序号==30 then
    商城处理类:数据处理(内容.数字id, 内容)
  elseif 序号==31 then
    local id = 内容.数字id
    地图处理类:更新称谓(内容.数字id,内容.称谓ID)
  elseif 序号==32 then
    玩家数据[内容.数字id].角色:增加奇经八脉(内容.数字id,内容.序列)
  elseif 序号==33 then
    if 玩家数据[内容.序列] ~= nil and 玩家数据[内容.序列].战斗 ~= nil and 玩家数据[内容.序列].战斗 ~= 0 and 玩家数据[内容.序列].观战 == nil  then
      if 玩家数据[内容.数字id].队伍 ~= 0 then
        常规提示(内容.数字id,"#Y/观战不能组队哟!......")
        return
      else
        战斗准备类.战斗盒子[玩家数据[内容.序列].战斗]:设置观战玩家(内容.序列,内容.数字id)
        玩家数据[内容.数字id].战斗 = 玩家数据[内容.序列].战斗
        玩家数据[内容.数字id].观战 = 1
      end
    elseif 玩家数据[内容.数字id].角色.数据.强P开关 ~= nil then
      玩家数据[内容.数字id].最后对话={}
      添加最后对话(内容.数字id,"你确定要对#R"..玩家数据[内容.序列].角色.数据.名称.."#Y强行进行PK么?",{"确定强行PK","我再考虑考虑！"})
      玩家数据[内容.数字id].强P对象 = 内容.序列
      return
    elseif 玩家数据[内容.数字id].角色.数据.PK开关 ~= nil and 玩家数据[内容.序列].角色.数据.PK开关 ~= nil then
      if 玩家数据[内容.序列].观战 ~= nil then
        if 战斗准备类.战斗盒子[玩家数据[内容.序列].战斗]~=nil  then
          战斗准备类.战斗盒子[玩家数据[内容.序列].战斗]:删除观战玩家(内容.序列)
          玩家数据[内容.序列].战斗=0
          玩家数据[内容.序列].观战=nil
          发送数据(玩家数据[内容.序列].连接id,5505)
        else
          玩家数据[内容.序列].战斗=0
          玩家数据[内容.序列].观战=nil
          发送数据(玩家数据[内容.序列].连接id,5505)
        end
      end
      战斗准备类:创建玩家战斗(内容.数字id, 200007, 内容.序列, 1501)
    elseif 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 1001 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6003 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6004 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6005 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6006 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6007 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6008 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6009 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6010 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6011 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6012 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6013 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6014 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6015 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6016 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6017 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6018 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6019 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6020 then
      常规提示(内容.数字id,"#Y只可以在长安擂台PK！")
      return 0
    elseif 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6003 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6004 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6005 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6006 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6007 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6008 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6009 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6010 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6011 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6012 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6013 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6014 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6015 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6016 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6017 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6018 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6019 and 玩家数据[内容.数字id].角色.数据.地图数据.编号 ~= 6020 and (取两点距离({x=8274,y=3426},{x=玩家数据[内容.数字id].角色.数据.地图数据.x,y=玩家数据[内容.数字id].角色.数据.地图数据.y})>400 or 取两点距离({x=8274,y=3426},{x=玩家数据[内容.序列].角色.数据.地图数据.x,y=玩家数据[内容.序列].角色.数据.地图数据.y})>400) then
      常规提示(内容.数字id,"#y/只有擂台之上才可以进行切磋")
      return 0
    else
      if 玩家数据[内容.序列].观战 ~= nil then
        if 战斗准备类.战斗盒子[玩家数据[内容.序列].战斗]~=nil  then
          战斗准备类.战斗盒子[玩家数据[内容.序列].战斗]:删除观战玩家(内容.序列)
          玩家数据[内容.序列].战斗=0
          玩家数据[内容.序列].观战=nil
          发送数据(玩家数据[内容.序列].连接id,5505)
        else
          玩家数据[内容.序列].战斗=0
          玩家数据[内容.序列].观战=nil
          发送数据(玩家数据[内容.序列].连接id,5505)
        end
      end
      if 玩家数据[内容.数字id].角色.数据.地图数据.编号 == 1001 then
          战斗准备类:创建玩家战斗(内容.数字id, 200003, 内容.序列, 1501)
      elseif 玩家数据[内容.数字id].角色.数据.地图数据.编号 == 6003 or 玩家数据[内容.数字id].角色.数据.地图数据.编号 == 6004 or 玩家数据[内容.数字id].角色.数据.地图数据.编号 == 6005 or 玩家数据[内容.数字id].角色.数据.地图数据.编号 == 6006 or 玩家数据[内容.数字id].角色.数据.地图数据.编号 == 6007 or 玩家数据[内容.数字id].角色.数据.地图数据.编号 == 6008 then
        if 比武大会开关 then
          战斗准备类:创建玩家战斗(内容.数字id, 200004, 内容.序列, 1501)
        else
          常规提示(内容.数字id,"当前为比武大会准备时间，无法进行比武！")
          return 0
        end
      elseif 玩家数据[内容.数字id].角色.数据.地图数据.编号 == 6009 then
        if 首席争霸开关 then
          战斗准备类:创建玩家战斗(内容.数字id, 200005, 内容.序列, 1501)
        else
          常规提示(内容.数字id,"当前为首席争霸准备时间，无法进行切磋！")
          return 0
        end
      elseif 玩家数据[内容.数字id].角色.数据.地图数据.编号 == 6010 or 玩家数据[内容.数字id].角色.数据.地图数据.编号 == 6011 or 玩家数据[内容.数字id].角色.数据.地图数据.编号 == 6012 or 玩家数据[内容.数字id].角色.数据.地图数据.编号 == 6013 or 玩家数据[内容.数字id].角色.数据.地图数据.编号 == 6014 or 玩家数据[内容.数字id].角色.数据.地图数据.编号 == 6015 or 玩家数据[内容.数字id].角色.数据.地图数据.编号 == 6016 or 玩家数据[内容.数字id].角色.数据.地图数据.编号 == 6017 or 玩家数据[内容.数字id].角色.数据.地图数据.编号 == 6018 or 玩家数据[内容.数字id].角色.数据.地图数据.编号 == 6019 or 玩家数据[内容.数字id].角色.数据.地图数据.编号 == 6020 then
        if 帮派竞赛开关 then
          战斗准备类:创建玩家战斗(内容.数字id, 200006, 内容.序列, 1501)
        else
          常规提示(内容.数字id,"当前为帮派竞赛准备时间，无法进行切磋！")
          return 0
        end
      end
    end
  elseif 序号==34 then
      self:创建账号(id,序号,内容)
  elseif 序号==35 then --玩法介绍分类
    发送数据(玩家数据[内容.数字id].连接id, 992, {内容=玩法介绍})
  elseif 序号==36 then --玩法介绍内容
    取玩法介绍(内容.数字id,内容.分类,内容.子类)
  elseif 序号==37 then
    玩家数据[内容.数字id].角色:删除称谓(内容.数字id,玩家数据[内容.数字id].角色.数据.称谓[内容.称谓ID])
  elseif 序号==38 then
    self:生死劫处理(内容.数字id,内容)
  elseif 序号==39 then
    self:统计排行榜(内容.数字id)
  elseif 序号==40 then
    if 活跃数据[内容.数字id]==nil then
      活跃数据[内容.数字id]={活跃度=0,领取100活跃=false,领取200活跃=false,领取300活跃=false,领取400活跃=false,领取500活跃=false,师门次数=20,官职次数=30,鬼怪次数=25,封妖次数=3,游泳次数=1,镖王次数=1,押镖次数=50,水果次数=25,天庭叛逆次数=25,十二星宿次数=5,门派闯关次数=1,地煞星次数=5,天罡星次数=5,飞贼次数=5,知了先锋=20,小知了王=20,知了王=10,世界BOSS次数=2,抓鬼次数=50,初出江湖次数=20,帮派青龙次数=100,帮派玄武次数=100,妖王次数=3}
    end
    发送数据(玩家数据[内容.数字id].连接id,88,{活跃数据=活跃数据[内容.数字id],累积活跃=玩家数据[内容.数字id].角色.数据.累积活跃})
  elseif 序号==41 then
    self:领取活跃度奖励(内容.数字id,内容)
  elseif 序号==42 then
    self:帮战报名处理(内容.数字id,内容)
  elseif 序号==43 then
    self:获取签到数据(内容.数字id)
  elseif 序号==44 then
    self:签到处理(内容.数字id,内容)
  elseif 序号==45 then
    self:获取VIP数据(内容.数字id)
  elseif 序号==46 then
    self:VIP领取奖励处理(内容.数字id,内容)
  elseif 序号==47 then
    self:获取点卡数据(内容.数字id)
  elseif 序号==48 then
    商城处理类:取商品组数据(内容.数字id, 19)
  elseif 序号==49 then
    地图处理类:移除玩家(内容.数字id)
  elseif 序号==50 then
    地图处理类:加入玩家(内容.数字id,玩家数据[内容.数字id].角色.数据.地图数据.编号,玩家数据[内容.数字id].角色.数据.地图数据.x,玩家数据[内容.数字id].角色.数据.地图数据.y)
  elseif 序号==60 then
    local 点卡=f函数.读配置(程序目录..[[data\]]..玩家数据[内容.数字id].账号..[[\账号信息.txt]],"账号配置","点卡")
    if 点卡 == nil or 点卡 == "" or 点卡 == "空" then
      f函数.写配置(程序目录..[[data\]]..玩家数据[内容.数字id].账号..[[\账号信息.txt]],"账号配置","点卡",0)
      点卡 = 0
    end
    发送数据(玩家数据[内容.数字id].连接id,92.2,{兑换比例=兑换比例,点卡=点卡})


    发送数据(玩家数据[内容.数字id].连接id,112,藏宝阁数据)
    if 观察藏宝阁数据 == nil then
      观察藏宝阁数据 = {}
    end
    观察藏宝阁数据[内容.数字id] = 1


  elseif 序号 == 60.1 then
    发送数据(玩家数据[内容.数字id].连接id, 113, 玩家数据[内容.数字id].道具:索要道具1(内容.数字id))
  elseif 序号 == 60.21 then
    发送数据(玩家数据[内容.数字id].连接id, 114, 玩家数据[内容.数字id].召唤兽.数据)
  elseif 序号 == 60.3 then
    发送数据(玩家数据[内容.数字id].连接id, 115, 玩家数据[内容.数字id].角色.数据.银子)
  elseif 序号 == 60.5 then --上架道具
    self:藏宝阁上架(内容.数字id,内容.编号,内容.价格)
  elseif 序号 == 60.6 then --上架召唤兽
    self:藏宝阁上架召唤兽(内容.数字id,内容.编号,内容.价格)
  elseif 序号 == 60.7 then --上架召唤兽
    观察藏宝阁数据[内容.数字id] = nil
  elseif 序号 == 60.8 then --上架银子
    self:藏宝阁上架银两(内容.数字id,内容.编号,内容.价格)
  elseif 序号 == 60.9 then --上架银子
    self:藏宝阁购买处理(内容.数字id,内容.编号,内容.类型)
  elseif 序号 == 60.4 then --上架银子
    self:藏宝阁取回处理(内容.数字id,内容.编号,内容.类型)
  elseif 序号 == 61 then --上架角色
    玩家数据[内容.数字id].角色.数据.藏宝阁出售 = 1
    藏宝阁数据.角色[#藏宝阁数据.角色+1] = {所有者=内容.数字id,价格=内容.编号,取回密码=内容.价格,结束时间=os.time()+604800,角色信息={账号=玩家数据[内容.数字id].账号,模型=玩家数据[内容.数字id].角色.数据.模型,名称=玩家数据[内容.数字id].角色.数据.名称,等级=玩家数据[内容.数字id].角色.数据.等级,门派=玩家数据[内容.数字id].角色.数据.门派}}
    --常规提示(内容.数字id,"#Y上架角色成功,即日起该角色将无法进入游戏,可以使用任意角色在XX处使用取回密码取回账号,请牢记你的取回密码:"..内容.价格)
    玩家数据[内容.数字id].角色:存档()
    发送数据(玩家数据[内容.数字id].连接id,998,"#Y上架角色成功,即日起该角色将无法进入游戏,可以使用任意角色在XX处使用取回密码取回账号,请牢记你的取回密码！")
    __S服务:连接退出(玩家数据[内容.数字id].连接id)
    for i,v in pairs(观察藏宝阁数据) do
      if 玩家数据[i] ~= nil then
        发送数据(玩家数据[i].连接id,116 , 藏宝阁数据)
      else
        观察藏宝阁数据[i] = nil
      end
    end
  elseif 序号 == 62 then --查看角色
    local id = 内容.数字id
    local 编号 = 内容.编号
    local 名称 = 内容.名称
    if 藏宝阁数据.角色[编号] == nil or 名称 ~= 藏宝阁数据.角色[编号].角色信息.名称 then
      常规提示(id,"#Y数据错误请重新打开藏宝阁")
      return
    end
    local 发送角色信息= {}
    发送角色信息.角色数据 = table.loadstring(读入文件([[data/]]..藏宝阁数据.角色[编号].角色信息.账号..[[/]]..藏宝阁数据.角色[编号].所有者..[[/角色.txt]]))
    发送角色信息.召唤兽数据 = table.loadstring(读入文件([[data/]]..藏宝阁数据.角色[编号].角色信息.账号..[[/]]..藏宝阁数据.角色[编号].所有者..[[/召唤兽.txt]]))
    local 道具数据 = table.loadstring(读入文件([[data/]]..藏宝阁数据.角色[编号].角色信息.账号..[[/]]..藏宝阁数据.角色[编号].所有者..[[/道具.txt]]))
    发送角色信息.装备数据 = {}
    for i=1,6 do
      if 发送角色信息.角色数据.装备[i] ~= nil and 道具数据[发送角色信息.角色数据.装备[i]] ~= nil then
        发送角色信息.装备数据[i] = 道具数据[发送角色信息.角色数据.装备[i]]
      end
    end
    发送角色信息.灵饰数据 = {}
     for i=1,4 do
      if 发送角色信息.角色数据.灵饰[i] ~= nil and 道具数据[发送角色信息.角色数据.灵饰[i]] ~= nil then
        发送角色信息.灵饰数据[i] = 道具数据[发送角色信息.角色数据.灵饰[i]]
      end
    end
    发送数据(玩家数据[id].连接id,117,发送角色信息)
    发送角色信息 = nil
    道具数据 = nil
  elseif 序号==63 then
    local id = 内容.数字id
    local 目标id = 内容.编号
    local 密码 = 内容.价格
    for i=1,#藏宝阁数据.角色 do
      if 藏宝阁数据.角色[i].所有者 == 目标id or tonumber(藏宝阁数据.角色[i].所有者) == tonumber(目标id) then
        if 藏宝阁数据.角色[i].取回密码 ~= 密码 then
          常规提示(id,"#Y密码错误请重新输入")
          return
        else
          local 角色信息 = table.loadstring(读入文件([[data/]]..藏宝阁数据.角色[i].角色信息.账号..[[/]]..藏宝阁数据.角色[i].所有者..[[/角色.txt]]))
          角色信息.藏宝阁出售 = nil
          写出文件([[data/]]..藏宝阁数据.角色[i].角色信息.账号..[[/]]..藏宝阁数据.角色[i].所有者..[[/角色.txt]],table.tostring(角色信息))
          角色信息 = nil
          table.remove(藏宝阁数据.角色,i)
          for i,v in pairs(观察藏宝阁数据) do
            if 玩家数据[i] ~= nil then
              发送数据(玩家数据[i].连接id,116 , 藏宝阁数据)
            else
              观察藏宝阁数据[i] = nil
            end
          end
          常规提示(id,"#Y恭喜角色成功取回,请原账号登录即可!!!")
          return
        end
      end
    end
  elseif 序号==87.1 or 序号==87.2 or 序号==87 or 序号 == 86 or 序号 == 85 or 序号 == 84 or 序号 == 83 or 序号 == 82 or 序号 == 81 or 序号 == 80 or 序号==79 or 序号==78 or 序号 == 77 or 序号 == 76 or 序号 == 75 then
    玩家数据[内容.数字id].助战:数据处理(序号,内容)
  elseif 序号==88 then
    发送数据(玩家数据[内容.数字id].连接id,101,玩家数据[内容.数字id].助战:取数据())
  elseif 序号 == 89 then
    local 序列=内容.序列
    local id=内容.数字id
    if 玩家数据[id].角色.数据.坐骑列表[序列]==nil then
      常规提示(id,"#Y你没有这样的坐骑")
      return
    else
      玩家数据[id].角色.数据.坐骑列表[序列].名称 = 内容.名称
    end
  elseif 序号 == 90 then
    local 序列=内容.序列
    local id=内容.数字id
    if 玩家数据[id].角色.数据.坐骑列表[序列]==nil then
      常规提示(id,"#Y你没有这样的坐骑")
      return
    elseif 玩家数据[id].摊位数据 ~= nil then
      常规提示(id,"#Y摆摊情况下无法进行此操作")
      return
    else
      if 玩家数据[id].角色.数据.坐骑列表[序列].统御召唤兽 == nil then
        玩家数据[id].角色.数据.坐骑列表[序列].统御召唤兽= {}
      end
      if #玩家数据[id].角色.数据.坐骑列表[序列].统御召唤兽 >= 2 then
        常规提示(id,"#Y该坐骑已经无法统御更多的召唤兽了")
        return
      elseif 玩家数据[id].召唤兽.数据[内容.召唤兽编号] == nil then
        常规提示(id,"#Y该召唤兽不存在")
        return
      elseif 玩家数据[id].召唤兽.数据[内容.召唤兽编号].统御 ~= nil then
        local 坐骑编号 = 玩家数据[id].召唤兽.数据[内容.召唤兽编号].统御
        if 玩家数据[id].角色.数据.坐骑列表[坐骑编号] ~= nil and 玩家数据[id].角色.数据.坐骑列表[坐骑编号].统御召唤兽 ~= nil then
          if 玩家数据[id].角色.数据.坐骑列表[坐骑编号].统御召唤兽[1] ~= nil  and 玩家数据[id].角色.数据.坐骑列表[坐骑编号].统御召唤兽[1] == 内容.召唤兽编号 then
            常规提示(id,"#Y该召唤兽被"..玩家数据[id].角色.数据.坐骑列表[玩家数据[id].召唤兽.数据[内容.召唤兽编号].统御].名称.."统御中,请解除统御后再进行此操作")
            return
          elseif 玩家数据[id].角色.数据.坐骑列表[坐骑编号].统御召唤兽[2] ~= nil  and 玩家数据[id].角色.数据.坐骑列表[坐骑编号].统御召唤兽[2] == 内容.召唤兽编号 then
            常规提示(id,"#Y该召唤兽被"..玩家数据[id].角色.数据.坐骑列表[玩家数据[id].召唤兽.数据[内容.召唤兽编号].统御].名称.."统御中,请解除统御后再进行此操作")
            return
          end
        end
      end
      玩家数据[id].角色.数据.坐骑列表[序列].统御召唤兽[#玩家数据[id].角色.数据.坐骑列表[序列].统御召唤兽+1] = 内容.召唤兽编号
      玩家数据[id].召唤兽.数据[内容.召唤兽编号].统御 = 序列
      玩家数据[id].召唤兽.数据[内容.召唤兽编号].统御属性.力量 =math.ceil(玩家数据[id].角色.数据.坐骑列表[序列].力量*0.1)
      玩家数据[id].召唤兽.数据[内容.召唤兽编号].统御属性.魔力 =math.ceil(玩家数据[id].角色.数据.坐骑列表[序列].魔力*0.1)
      玩家数据[id].召唤兽.数据[内容.召唤兽编号].统御属性.体质 =math.ceil(玩家数据[id].角色.数据.坐骑列表[序列].体质*0.1)
      玩家数据[id].召唤兽.数据[内容.召唤兽编号].统御属性.敏捷 =math.ceil(玩家数据[id].角色.数据.坐骑列表[序列].敏捷*0.1)
      玩家数据[id].召唤兽.数据[内容.召唤兽编号].统御属性.耐力 =math.ceil(玩家数据[id].角色.数据.坐骑列表[序列].耐力*0.1)
      玩家数据[id].召唤兽:刷新信息(内容.召唤兽编号,"1")
      发送数据(玩家数据[id].连接id,20,玩家数据[id].召唤兽:取存档数据(内容.召唤兽编号))
      发送数据(玩家数据[id].连接id,61.1,{编号=序列,数据=玩家数据[id].角色.数据.坐骑列表[序列]})
      常规提示(id,"#Y统御该召唤兽成功")
    end
  elseif 序号 == 91 then
    local 序列=内容.序列
    local id=内容.数字id
    local 召唤兽编号 = 玩家数据[id].角色.数据.坐骑列表[序列].统御召唤兽[内容.编号]
    if 玩家数据[id].角色.数据.坐骑列表[序列]==nil then
      常规提示(id,"#Y你没有这样的坐骑")
      return
    elseif  玩家数据[id].角色.数据.坐骑列表[序列].统御召唤兽[内容.编号] == nil then
      常规提示(id,"#Y统御信息不存在")
    elseif 玩家数据[id].召唤兽.数据[召唤兽编号] == nil then
      table.remove(玩家数据[id].角色.数据.坐骑列表[序列].统御召唤兽,内容.编号)
      常规提示(id,"#Y已经结束对该召唤兽的统御")
    else
      玩家数据[id].召唤兽.数据[召唤兽编号].统御 = nil
      玩家数据[id].召唤兽.数据[召唤兽编号].统御属性.力量 = 0
      玩家数据[id].召唤兽.数据[召唤兽编号].统御属性.魔力 = 0
      玩家数据[id].召唤兽.数据[召唤兽编号].统御属性.体质 = 0
      玩家数据[id].召唤兽.数据[召唤兽编号].统御属性.敏捷 = 0
      玩家数据[id].召唤兽.数据[召唤兽编号].统御属性.耐力 = 0
      玩家数据[id].召唤兽:刷新信息(召唤兽编号,"1")
      发送数据(玩家数据[id].连接id,20,玩家数据[id].召唤兽:取存档数据(玩家数据[id].角色.数据.坐骑列表[序列].统御召唤兽[内容.编号]))
      table.remove(玩家数据[id].角色.数据.坐骑列表[序列].统御召唤兽,内容.编号)
      常规提示(id,"#Y已经结束对该召唤兽的统御")
    end
    发送数据(玩家数据[id].连接id,61.1,{编号=序列,数据=玩家数据[id].角色.数据.坐骑列表[序列]})
  elseif 序号 == 92 then
    local 序列=内容.编号
    local id=内容.数字id
    local 经验 = 100000*内容.次数
    local 银子 = 10000*内容.次数
    if 玩家数据[id].角色.数据.坐骑列表[序列]==nil then
      常规提示(id,"#Y你没有这样的坐骑")
      return
    else
      if 取银子(id)<银子 then
          常规提示(id,"#Y/你当前的银子好像不够哟!")
          return
      elseif 玩家数据[id].角色.数据.当前经验 < 经验 then
          常规提示(id,"#Y/你当前的经验好像不够哟!")
          return
      end
      if 玩家数据[id].角色.数据.坐骑列表[序列].等级>=玩家数据[id].角色.数据.等级 then
         常规提示(id,"#Y坐骑等级最高为人物等级")
         return
      end
      玩家数据[id].角色.数据.当前经验=玩家数据[id].角色.数据.当前经验-经验
      玩家数据[id].角色:坐骑喂养(序列,经验)
      玩家数据[id].角色:扣除银子(银子,0,0,"坐骑训养",1)
    end
  elseif 序号 == 92.1 then
    local 序列=内容.编号
    local id=内容.数字id
    local 次数=内容.次数
    local 银子
    local 一次银子 = 玩家数据[id].角色.数据.坐骑列表[序列].修炼.速度修炼[1]*100000
    local 十次银子 = (玩家数据[id].角色.数据.坐骑列表[序列].修炼.速度修炼[1]*10+45)*100000
    local 五十次银子 = (玩家数据[id].角色.数据.坐骑列表[序列].修炼.速度修炼[1]*50+1225)*100000
    if 玩家数据[id].角色.数据.坐骑列表[序列]==nil then
      常规提示(id,"#Y你没有这样的坐骑")
      return
    else
      if 次数==1 then
        if 取银子(id)<一次银子 then
           常规提示(id,"#Y/你的银子好像不够本次坐骑提速")
        return
        else
        银子=一次银子
        end
      end
      if 次数==10 then
        if 取银子(id)<十次银子 then
           常规提示(id,"#Y/你的银子好像不够本次坐骑提速")
        return
        else
        银子=十次银子
        end
      end
      if 次数==50 then
        if 取银子(id)<五十次银子 then
           常规提示(id,"#Y/你的银子好像不够本次坐骑提速")
        return
        else
        银子=五十次银子
        end
    end
      if  玩家数据[id].角色.数据.坐骑列表[序列].修炼.速度修炼[1]+次数>200 then
          常规提示(id,"#Y/您的本次坐骑提速，将会高于提速上限，上限为300%的移动速度")
          return
      end
      if  玩家数据[id].角色.数据.坐骑列表[序列].修炼.速度修炼[1]>=200 then
          玩家数据[id].角色.数据.坐骑列表[序列].修炼.速度修炼[1]=200
          常规提示(id,"#Y/您的坐骑移动速度已经达到极限，无法继续提速")
          return
      end
      玩家数据[id].角色:扣除银子(银子,0,0,"坐骑提速",1)
      玩家数据[id].角色:坐骑提速(序列,次数)
    end
  elseif 序号 == 93 then
    local 序列=内容.编号
    local id=内容.数字id
    if 玩家数据[id].角色.数据.坐骑列表[序列]==nil then
      常规提示(id,"#Y你没有这样的坐骑")
      return
    else
      玩家数据[id].角色:坐骑加点(序列,内容.加点)
    end
  elseif 序号 == 94 then
    local 序列=内容.编号
    local id=内容.数字id
    if 玩家数据[id].角色.数据.坐骑列表[序列]==nil then
      常规提示(id,"#Y你没有这样的坐骑")
      return
    elseif 取银子(id)<30000 then
      常规提示(id,"#Y/你当前的银子好像不够哟!")
      return
    else
      玩家数据[id].角色:扣除银子(30000,0,0,"坐骑洗点",1)
      玩家数据[id].角色:坐骑洗点(序列)
    end
  elseif 序号 == 95 then
    local 序列=内容.编号
    local id=内容.数字id
    if 玩家数据[id].角色.数据.坐骑列表[序列]==nil then
      常规提示(id,"#Y你没有这样的坐骑")
      return
    else
      玩家数据[id].角色:坐骑放生(序列)
    end
  elseif 序号 == 96 then
    local 序列=内容.编号
    local id=内容.数字id
    for i=1,#玩家数据[id].角色.数据.坐骑列表 do
      if 玩家数据[id].角色.数据.坐骑列表[i].技能点 == nil then
        玩家数据[id].角色.数据.坐骑列表[i].技能点 = 0
      end
    end
    发送数据(玩家数据[id].连接id,61.2,玩家数据[id].角色.数据.坐骑列表)
  elseif 序号 == 97 then
    local 序列=内容.编号
    local id=内容.数字id
    if 玩家数据[id].角色.数据.坐骑列表[序列]==nil then
      常规提示(id,"#Y你没有这样的坐骑")
      return
    elseif 取银子(id)<50000 then
      常规提示(id,"#Y/你当前的银子好像不够哟!")
      return
    else
      玩家数据[id].角色:扣除银子(50000,0,0,"坐骑喂养",1)
      if 玩家数据[id].角色.数据.坐骑列表[序列].忠诚 >= 50 then
        玩家数据[id].角色.数据.坐骑列表[序列].忠诚 = 玩家数据[id].角色.数据.坐骑列表[序列].忠诚 + 取随机数(3,6)
      else
        玩家数据[id].角色.数据.坐骑列表[序列].忠诚 = 玩家数据[id].角色.数据.坐骑列表[序列].忠诚 + 取随机数(6,10)
      end
      if 玩家数据[id].角色.数据.坐骑列表[序列].忠诚>= 100 then
        玩家数据[id].角色.数据.坐骑列表[序列].忠诚 = 100
      end
      玩家数据[id].角色:坐骑刷新(序列)
    end
  elseif 序号 == 98 then
    local 序列=内容.编号
    local id=内容.数字id
    if 玩家数据[id].角色.数据.坐骑列表[序列]==nil then
      常规提示(id,"#Y你没有这样的坐骑")
      return
    elseif 玩家数据[id].角色.数据.坐骑列表[序列].技能点<1 then
      常规提示(id,"#Y你没有足够的技能点")
      return
    else
      local 编号 = 内容.技能编号
      local 技能名称 = 内容.名称
      if 玩家数据[id].角色.数据.坐骑列表[序列].技能[编号] ~= nil  and 玩家数据[id].角色.数据.坐骑列表[序列].技能[编号] == 技能名称 then
        if 玩家数据[id].角色.数据.坐骑列表[序列].技能等级 == nil then
          玩家数据[id].角色.数据.坐骑列表[序列].技能等级 = {}
        end
        if 玩家数据[id].角色.数据.坐骑列表[序列].技能等级[编号] == nil then
          玩家数据[id].角色.数据.坐骑列表[序列].技能等级[编号] = 1
          玩家数据[id].角色.数据.坐骑列表[序列].技能点 = 玩家数据[id].角色.数据.坐骑列表[序列].技能点 -1
          发送数据(玩家数据[id].连接id,61.1,{编号=序列,数据=玩家数据[id].角色.数据.坐骑列表[序列]})
        elseif 玩家数据[id].角色.数据.坐骑列表[序列].技能等级[编号] >= 3 then
          常规提示(id,"#Y该技能以及升到顶级")
          return
        else
          玩家数据[id].角色.数据.坐骑列表[序列].技能等级[编号] = 玩家数据[id].角色.数据.坐骑列表[序列].技能等级[编号] + 1
          玩家数据[id].角色.数据.坐骑列表[序列].技能点 = 玩家数据[id].角色.数据.坐骑列表[序列].技能点 -1
          if  玩家数据[id].角色.数据.坐骑列表[序列].技能等级[编号] >= 3 then
            玩家数据[id].角色.数据.坐骑列表[序列].技能[编号] = "高级"..技能名称
          end
          发送数据(玩家数据[id].连接id,61.1,{编号=序列,数据=玩家数据[id].角色.数据.坐骑列表[序列]})
          常规提示(id,"#Y技能升级成功")
        end
      end
    end
  elseif 序号 == 99 then
    炼丹查看[内容.数字id] = nil
  elseif 序号 == 99.1 then
    游戏活动类:炼丹下注(内容)
  elseif 序号 == 100 then
    local id = 内容.数字id
    if 内充开启 then
      local 充值回执 = 处理充值(内容.卡号)

      if 充值回执  == "0" then
        常规提示(id,"#Y该卡号不存在！")
        return
      elseif 充值回执 == "已使用" then
        常规提示(id,"#Y该卡号已被使用！")
        return
      elseif tonumber(充值回执) == nil then
        常规提示(id,"#Y该卡号面值异常请联系管理员处理！")
        return
      elseif tonumber(充值回执) == 1 then
        local 经验 = 88800
        if VIP数据[id]==nil then
          VIP数据[id].VIP经验 = 0
          VIP数据[id].VIP1状态 = false
          VIP数据[id].VIP2状态 = false
          VIP数据[id].VIP3状态 = false
          VIP数据[id].VIP4状态 = false
          VIP数据[id].VIP5状态 = false
        end
        VIP数据[id].VIP经验= 经验
        常规提示(id,"#Y你获得了"..经验.."积分！请重新打开界面领取VIP")
      else
        常规提示(id,"#Y充值点卡成功！")
        local 点卡=f函数.读配置(程序目录..[[data\]]..玩家数据[id].账号..[[\账号信息.txt]],"账号配置","点卡") + 0
        点卡 = 点卡 + tonumber(充值回执)
        f函数.写配置(程序目录..[[data\]]..玩家数据[id].账号..[[\账号信息.txt]],"账号配置","点卡",点卡)
        local 日志=读入文件([[data\]]..玩家数据[id].账号..[[\消费记录.txt]])
        日志=日志.."\n"..时间转换(os.time())..format("。以下为具体信息：增加数额为%s点点卡，增加之后剩余点卡%s点。本次操作的角色id为%s#分割符\n",充值回执+0,点卡,id)
        写出文件([[data\]]..玩家数据[id].账号..[[\消费记录.txt]],日志)
        发送数据(玩家数据[id].连接id,91.1,{点卡=点卡})
        __S服务:输出(玩家数据[id].账号.."使用充值卡【"..内容.卡号.."】充值"..充值回执.."点卡成功！")
      end
    else
      常规提示(id,"#Y内充系统异常,请联系管理员处理！")
    end
  elseif 序号 == 100.1 then
    local id = 内容.数字id
    local 消耗数额 = math.ceil(内容.数额/兑换比例)
    local 点卡=f函数.读配置(程序目录..[[data\]]..玩家数据[id].账号..[[\账号信息.txt]],"账号配置","点卡") + 0
    local 之前 = 点卡
    if 点卡 < 消耗数额 then
      常规提示(id,"#Y你没有这么多的点卡可以使用！")
      return
    else
      常规提示(id,"#Y兑换仙玉成功！")
      点卡 = 点卡 - 消耗数额
      f函数.写配置(程序目录..[[data\]]..玩家数据[id].账号..[[\账号信息.txt]],"账号配置","点卡",点卡)
      local 日志=读入文件([[data\]]..玩家数据[id].账号..[[\消费记录.txt]])
      日志=日志.."\n"..时间转换(os.time())..format("。以下为具体扣费信息：扣除数额为%s点点卡，扣除之前点卡数额为%s点，扣除之后剩余点卡%s点。本次操作的角色id为%s#分割符\n",消耗数额,之前,点卡,id)
      写出文件([[data\]]..玩家数据[id].账号..[[\消费记录.txt]],日志)
      添加仙玉(内容.数额,玩家数据[id].账号,id,"点卡兑换")
      发送数据(玩家数据[id].连接id,91.1,{点卡=点卡})
    end
  elseif 序号 == 100.2 then
    local id = 内容.数字id
    if 内充开启 then
      local 充值回执 = 处理充值(内容.卡号)
      if 充值回执  == "0" then
        常规提示(id,"#Y该卡号不存在！")
        return
      elseif 充值回执 == "已使用" then
        常规提示(id,"#Y该卡号已被使用！")
        return
      elseif tonumber(充值回执) == nil then
        常规提示(id,"#Y该卡号面值异常请联系管理员处理！")
        return
      else
        常规提示(id,"#Y充值点卡成功！")
        local 点卡=f函数.读配置(程序目录..[[data\]]..玩家数据[id].账号..[[\账号信息.txt]],"账号配置","点卡") + 0
        点卡 = 点卡 + tonumber(充值回执)
        f函数.写配置(程序目录..[[data\]]..玩家数据[id].账号..[[\账号信息.txt]],"账号配置","点卡",点卡)
        local 日志=读入文件([[data\]]..玩家数据[id].账号..[[\消费记录.txt]])
        日志=日志.."\n"..时间转换(os.time())..format("。以下为具体信息：增加数额为%s点点卡，增加之后剩余点卡%s点。本次操作的角色id为%s#分割符\n",充值回执+0,点卡,id)
        写出文件([[data\]]..玩家数据[id].账号..[[\消费记录.txt]],日志)
        发送数据(玩家数据[id].连接id,92.1,{点卡=点卡})
        __S服务:输出(玩家数据[id].账号.."使用充值卡【"..内容.卡号.."】充值"..充值回执.."点卡成功！")
      end
    else
      常规提示(id,"#Y内充系统异常,请联系管理员处理！")
    end
  elseif 序号 == 100.3 then
    local id = 内容.数字id
    local 消耗数额 = math.ceil(内容.数额/兑换比例)
    local 点卡=f函数.读配置(程序目录..[[data\]]..玩家数据[id].账号..[[\账号信息.txt]],"账号配置","点卡") + 0
    local 之前 = 点卡
    if 点卡 < 消耗数额 then
      常规提示(id,"#Y你没有这么多的点卡可以使用！")
      return
    else
      常规提示(id,"#Y兑换仙玉成功！")
      点卡 = 点卡 - 消耗数额
      f函数.写配置(程序目录..[[data\]]..玩家数据[id].账号..[[\账号信息.txt]],"账号配置","点卡",点卡)
      local 日志=读入文件([[data\]]..玩家数据[id].账号..[[\消费记录.txt]])
      日志=日志.."\n"..时间转换(os.time())..format("。以下为具体扣费信息：扣除数额为%s点点卡，扣除之前点卡数额为%s点，扣除之后剩余点卡%s点。本次操作的角色id为%s#分割符\n",消耗数额,之前,点卡,id)
      写出文件([[data\]]..玩家数据[id].账号..[[\消费记录.txt]],日志)
      添加仙玉(内容.数额,玩家数据[id].账号,id,"点卡兑换")
      发送数据(玩家数据[id].连接id,92.1,{点卡=点卡})
    end
  elseif 序号 == 101 then
    local id = 内容.数字id
    local 任务id=玩家数据[id].角色:取任务(7758)
    if 任务id==0 then
      常规提示(id,"#Y/你没有这样的任务")
      return
    elseif 检查格子(id)==false then
      常规提示(id,"#Y/你身上没有足够的空间")
      return
    end
    local 类型 =内容.类型
    if 类型 == 1 or 类型 == 2 or 类型 == 3 then
      local 星级 = 任务数据[任务id].星级
      if 类型 == 3 then
        local a=1
        local 通用特技 = {"气疗术","心疗术","命疗术","凝气诀","凝神诀","气归术","命归术","四海升平","回魂咒","起死回生","水清诀","冰清诀","玉清诀","晶清诀","弱点击破","冥王爆杀","放下屠刀","河东狮吼","碎甲术","破甲术","破血狂攻","罗汉金钟","慈航普渡","太极护法","光辉之甲","圣灵之甲","野兽之力","魔兽之印"}
        for i=1,#通用特技 do
          if 内容.数据 == 通用特技[i] then
            a=2
          end
        end
        if a == 1 then
          常规提示(id,"#Y/请检查输入的特技是否正确")
          return
        end
      elseif 类型 == 2 then
        if 内容.数据 == "愤怒" or 内容.数据 == "暴怒" then
          if 任务数据[任务id].序列 ~= 22 then
            常规提示(id,"#Y/暴怒和愤怒只能给腰带使用")
            return
          end
        end
      elseif 类型 == 1 then
        if 内容.双加1 == 内容.双加2  then
          常规提示(id,"#Y/双加属性不能相同")
          return
        elseif 任务数据[任务id].序列 ~= 21 and 任务数据[任务id].序列 > 18 then
          常规提示(id,"#Y/双加只有武器和衣服可以指定")
          return
        end
      end
      if 玩家数据[id].角色:扣除仙玉((星级+1)*10000,"指定系统",id) then
        if 类型 == 1 then
          任务数据[任务id].指定.双加 = {[1]=内容.双加1,[2]=内容.双加2}
        elseif 类型 == 2 then
          任务数据[任务id].指定.特效 = 内容.数据
        elseif 类型 == 3 then
          任务数据[任务id].指定.特技 = 内容.数据
        end
        常规提示(id,"#Y/指定数据成功")
      else
        常规提示(id,"#Y/你没有这么多的仙玉")
      end
    elseif 类型 == 4 then
      玩家数据[id].装备:添加熔合装备属性(id,任务id)
    end
    elseif 序号 == 102.2 then
    if 玩家数据[内容.数字id].角色:扣除元宝(50,"人物炫彩",内容.数字id)  then
      if 玩家数据[内容.数字id].角色.数据.炫彩 == nil then
        玩家数据[内容.数字id].角色.数据.炫彩 = 玩家数据[内容.数字id].角色.数据.染色方案
        玩家数据[内容.数字id].角色.数据.炫彩组 ={}
      end
      玩家数据[内容.数字id].角色.数据.炫彩组=内容.炫彩
      常规提示(内容.数字id,"角色染色成功")
      发送数据(玩家数据[内容.数字id].连接id,122.2,{炫彩=玩家数据[内容.数字id].角色.数据.炫彩,炫彩组=玩家数据[内容.数字id].角色.数据.炫彩组})
      地图处理类:更改炫彩(内容.数字id,玩家数据[内容.数字id].角色.数据.炫彩,玩家数据[内容.数字id].角色.数据.炫彩组)
    end
elseif 序号 == 103.1 then
    发送数据(id,117.1,点歌列表)
  elseif 序号 == 104.1 then
    if os.time() - 点歌状态 >= 340 then
      点歌状态 = os.time()
      if 玩家数据[内容.数字id].角色:扣除仙玉(100,"梦幻祝福",内容.数字id)  then
        广播祝福(内容.歌曲,玩家数据[内容.数字id].角色.数据.名称.."为大家送祝福")
        发送公告("#R"..玩家数据[内容.数字id].角色.数据.名称.."#G为大家点播了一首".."#R"..内容.歌曲.."#G祝大家游戏愉快天天好心情,所有在线玩家获得普天同庆经验增加#R100000")
      end
    else
      常规提示(内容.数字id,"#Y/请稍等一会在点歌")
    end


   elseif 序号 == 102.1 then
    self:获取天梯系统数据(内容.数字id)
  elseif 序号 == 103 then
    self:写入天梯数据匹配池(内容.数字id)
  elseif 序号 == 104 then
    self:开始天梯竞技匹配(内容.数字id)
  elseif 序号 == 105 then
    self:取消天梯竞技匹配(内容.数字id)
    -----------------------------
  elseif 序号 == 106 then
    self:写入天梯数据匹配池3(内容.数字id)
  elseif 序号 == 107 then
    self:写入天梯数据匹配池5(内容.数字id)
  elseif 序号 == 108 then
    self:重置天梯匹配模式(内容.数字id)
-------------元神突破-------------
  elseif 序号 == 110 then
    元神突破类:获取元神突破数据(内容.数字id)
  elseif 序号 == 111 then
    --常规提示(内容.数字id,"#Y/请等待GM通知再突破，否则后果自负")
    玩家数据[内容.数字id].角色:元神突破(id)
  elseif 序号 == 112 then
    玩家数据[内容.数字id].角色:快捷门派传送(id)
  end
end
--end

function 系统处理类:藏宝阁取回处理(id,编号,类型)
  local 关键字 = "其他"
  if 类型 == 1 then
    关键字 = "装备"
  elseif 类型 == 3 then
    关键字 = "灵饰"
  elseif 类型 == 4 then
    关键字 = "召唤兽"
  elseif 类型 == 5 then
    关键字 = "银两"
  elseif 类型 == 6 then
    关键字 = "其他"
  end
  if 类型 == 7 then
    发送数据(玩家数据[id].连接id, 7, "#y/取回角色请前往XXXX取回")
    return 0
  elseif 藏宝阁数据[关键字][编号] == nil then
    发送数据(玩家数据[id].连接id, 7, "#y/数据已经刷新请重新打开藏宝阁")
    return 0
  elseif 藏宝阁数据[关键字][编号].结束时间 - os.time() <= 30 then
    发送数据(玩家数据[id].连接id, 7, "#y/该物品即将超时下架,无法进行取回处理")
    return 0
  elseif 藏宝阁数据[关键字][编号].所有者 ~= id then
    发送数据(玩家数据[id].连接id, 7, "#y/这不是你的商品你无法取回")
    return 0
  else
    if 关键字 ~= "银两" and 关键字 ~= "召唤兽" then
      self.临时格子=玩家数据[id].角色:取道具格子()
      if self.临时格子==0 then
       发送数据(玩家数据[id].连接id,7,"#y/您当前的包裹空间已满，无法取回")
        return 0
      end
      self.可用id = 玩家数据[id].道具:取新编号()
      玩家数据[id].道具.数据[self.可用id] = 藏宝阁数据[关键字][编号].物品
      玩家数据[id].角色.数据.道具[self.临时格子] = self.可用id
      table.remove(藏宝阁数据[关键字],编号)
      发送数据(玩家数据[id].连接id,7,"#y/取回物品成功")
    elseif 关键字 == "银两" then
      玩家数据[id].角色:添加银子(藏宝阁数据[关键字][编号].数额,"藏宝阁取回"..关键字,1)
      table.remove(藏宝阁数据[关键字],编号)
      发送数据(玩家数据[id].连接id,7,"#y/恭喜你取回物品成功")
    elseif 关键字 == "召唤兽" then
      if #玩家数据[id].召唤兽.数据 >= 7 then
        发送数据(玩家数据[id].连接id,7,"#y/您的召唤兽空间已满，无法取回")
          return 0
      else
        玩家数据[id].召唤兽.数据[#玩家数据[id].召唤兽.数据+1] = 藏宝阁数据[关键字][编号].召唤兽
        table.remove(藏宝阁数据[关键字],编号)
        发送数据(玩家数据[id].连接id,7,"#y/恭喜你取回物品成功")
      end
    end
    for i,v in pairs(观察藏宝阁数据) do
      if 玩家数据[i] ~= nil then
        发送数据(玩家数据[i].连接id,116 , 藏宝阁数据)
      else
        观察藏宝阁数据[i] = nil
      end
    end
  end
end

function 系统处理类:藏宝阁购买处理(id,编号,类型)
  local 关键字 = "其他"
  if 类型 == 1 then
    关键字 = "装备"
  elseif 类型 == 3 then
    关键字 = "灵饰"
  elseif 类型 == 4 then
    关键字 = "召唤兽"
  elseif 类型 == 5 then
    关键字 = "银两"
  elseif 类型 == 6 then
    关键字 = "其他"
  elseif 类型 == 7 then
    关键字 = "角色"
  end
  if 藏宝阁数据[关键字][编号] == nil then
    发送数据(玩家数据[id].连接id, 7, "#y/数据已经刷新请重新打开藏宝阁")
    return 0
  elseif 藏宝阁数据[关键字][编号].结束时间 - os.time() <= 30 then
    发送数据(玩家数据[id].连接id, 7, "#y/该物品即将超时下架,无法进行购买处理")
    return 0
  else
    local 价格 = tonumber(藏宝阁数据[关键字][编号].价格)
    if 价格 == nil  then
        return
    end
    local 买家价格 = math.floor(价格)
    local 点卡=f函数.读配置(程序目录..[[data\]]..玩家数据[id].账号..[[\账号信息.txt]],"账号配置","点卡")
    if 点卡==nil or 点卡=="空" then
        f函数.写配置(程序目录..[[data\]]..玩家数据[id].账号..[[\账号信息.txt]],"账号配置","点卡","0")
        点卡=0
    end
    if 点卡+0<买家价格 then
      常规提示(id,"点卡不够哦!!请注意充值购买!!!")
      return
    end

    local 对方id = 藏宝阁数据[关键字][编号].所有者
    if 关键字 ~= "银两" and 关键字 ~= "召唤兽" and 关键字 ~= "角色" then
      self.临时格子=玩家数据[id].角色:取道具格子()
      if self.临时格子==0 then
        发送数据(玩家数据[id].连接id,7,"#y/您当前的包裹空间已满，无法购买")
        return 0
      end
      self.可用id = 玩家数据[id].道具:取新编号()
      玩家数据[id].道具.数据[self.可用id] = 藏宝阁数据[关键字][编号].物品
      玩家数据[id].角色.数据.道具[self.临时格子] = self.可用id
      藏宝阁记录 = 藏宝阁记录..玩家数据[id].角色.数据.名称.."通过藏宝阁购买ID:"..藏宝阁数据[关键字][编号].所有者.."物品["..藏宝阁数据[关键字][编号].物品.名称.."]花费"..价格.."银两\n"
      table.remove(藏宝阁数据[关键字],编号)
      发送数据(玩家数据[id].连接id,7,"#y/恭喜你购买物品成功")
    elseif 关键字 == "银两" then
      玩家数据[id].角色:添加银子(藏宝阁数据[关键字][编号].数额,"藏宝阁购买"..关键字,1)
      藏宝阁记录 = 藏宝阁记录..玩家数据[id].角色.数据.名称.."通过藏宝阁购买ID:"..藏宝阁数据[关键字][编号].所有者.."物品["..藏宝阁数据[关键字][编号].数额.."两银子]花费"..价格.."银两\n"
      table.remove(藏宝阁数据[关键字],编号)
      发送数据(玩家数据[id].连接id,7,"#y/恭喜你购买物品成功")
    elseif 关键字 == "召唤兽" then
      if #玩家数据[id].召唤兽.数据 >= 7 then
        发送数据(玩家数据[id].连接id,7,"#y/您的召唤兽空间已满，无法购买")
        return 0
      else
        玩家数据[id].召唤兽.数据[#玩家数据[id].召唤兽.数据+1] = 藏宝阁数据[关键字][编号].召唤兽
        藏宝阁记录 = 藏宝阁记录..玩家数据[id].角色.数据.名称.."通过藏宝阁购买ID:"..藏宝阁数据[关键字][编号].所有者.."物品["..藏宝阁数据[关键字][编号].召唤兽.名称.."]花费"..价格.."银两\n"
        table.remove(藏宝阁数据[关键字],编号)
        发送数据(玩家数据[id].连接id,7,"#y/恭喜你购买物品成功")
      end
    elseif 关键字 == "角色" then
      local 账号信息 = table.loadstring(读入文件([[data/]]..玩家数据[id].角色.数据.账号..[[/信息.txt]]))
      if #账号信息 >= 6 then
        发送数据(玩家数据[id].连接id,7,"#y/您的账号信息已满,无法购买新的角色")
        return
      elseif 玩家数据[id].角色.数据.账号 == 藏宝阁数据[关键字][编号].角色信息.账号 then
        发送数据(玩家数据[id].连接id,7,"#y/你不能购买自己的角色")
        return
      end
      账号信息[#账号信息+1] = 藏宝阁数据[关键字][编号].所有者
      写出文件([[data/]]..玩家数据[id].角色.数据.账号..[[/]].."/信息.txt",table.tostring(账号信息))
      账号信息 = {}
      local 账号 = 藏宝阁数据[关键字][编号].角色信息.账号
      账号信息 = table.loadstring(读入文件([[data/]]..账号..[[/信息.txt]]))
      for i=1,#账号信息 do
        if 账号信息[i] == 藏宝阁数据[关键字][编号].所有者 or tonumber(账号信息[i]) == 藏宝阁数据[关键字][编号].所有者 then
          table.remove(账号信息,i)
        end
      end
      写出文件([[data/]]..账号..[[/]].."/信息.txt",table.tostring(账号信息))
      local 角色信息=table.loadstring(读入文件([[data/]]..账号..[[/]]..藏宝阁数据[关键字][编号].所有者..[[/角色.txt]]))
      角色信息.账号 = 玩家数据[id].角色.数据.账号
      角色信息.藏宝阁出售 = nil
      写出文件([[data/]]..账号..[[/]]..藏宝阁数据[关键字][编号].所有者..[[/角色.txt]],table.tostring(角色信息))
      角色信息 = nil
      if 移动文件(账号,tostring(藏宝阁数据[关键字][编号].所有者),玩家数据[id].角色.数据.账号) == "0" then
        藏宝阁记录 = 藏宝阁记录..玩家数据[id].角色.数据.名称.."ID为:"..id.."通过藏宝阁购买ID:"..藏宝阁数据[关键字][编号].所有者.."角色花费"..价格.."银两,角色移除异常,请检查!\n"
      else
        藏宝阁记录 = 藏宝阁记录..玩家数据[id].角色.数据.名称.."ID为:"..id.."通过藏宝阁购买ID:"..藏宝阁数据[关键字][编号].所有者.."角色花费"..价格.."银两,角色转换成功!\n"
      end
      table.remove(藏宝阁数据[关键字],编号)
      发送数据(玩家数据[id].连接id,7,"#y/恭喜你购买物品成功")
    end
    玩家数据[id].角色:扣除点卡(买家价格,"藏宝阁购买",id)
    发送数据(玩家数据[id].连接id,7,"#y/支付:"..买家价格.."点点卡!")
    if 玩家数据[对方id] == nil then
      if 寄存数据[对方id] == nil then
        寄存数据[对方id] = {[1]={类型="点卡",数额=价格}}
      else
        寄存数据[对方id][#寄存数据[对方id]+1] = {类型="点卡",数额=价格}
      end
    else
        添加点卡(math.floor(价格),玩家数据[对方id].账号,对方id,"藏宝阁出售")
        发送数据(玩家数据[对方id].连接id,7,"#y/藏宝阁物品成功出售,并获得"..价格.."点点卡!!!")
    end
    for i,v in pairs(观察藏宝阁数据) do
      if 玩家数据[i] ~= nil then
        发送数据(玩家数据[i].连接id,116 , 藏宝阁数据)
      else
        观察藏宝阁数据[i] = nil
      end
    end
  end
end

function 系统处理类:藏宝阁上架召唤兽(id,编号,价格)
  if 玩家数据[id].召唤兽.数据[编号] == nil then
    发送数据(玩家数据[id].连接id, 7, "#y/你没有这样的召唤兽")
    return 0
  elseif 玩家数据[id].召唤兽:是否有装备(编号)  then
    发送数据(玩家数据[id].连接id, 7, "#y/请将该召唤兽装备卸下后再进行交易")
    return 0
  elseif tonumber(价格) == nil or tonumber(价格) < 1 then
    发送数据(玩家数据[id].连接id, 7, "#y/请正确输入物品的价格")
    return 0
  elseif 玩家数据[id].召唤兽:是否有统御()  then
    发送数据(玩家数据[id].连接id, 7, "#y/请将所有召唤兽统御效果撤除后再进行交易")
    return 0
  elseif #玩家数据[id].召唤兽.数据[编号].技能 <  7 then
    发送数据(玩家数据[id].连接id, 7, "#y/召唤兽上架技能要求最少8个")
    return 0
  -- elseif 玩家数据[id].召唤兽.数据[编号].成长 <  1.3 then
  --   发送数据(玩家数据[id].连接id, 7, "#y/召唤兽上架技能要求最少12个")
  --   return 0
  else
    藏宝阁数据["召唤兽"][#藏宝阁数据["召唤兽"]+1] = {召唤兽=玩家数据[id].召唤兽.数据[编号],价格=价格,所有者=id,结束时间=os.time()+204800}
    if 玩家数据[id].召唤兽.数据[编号].认证码==玩家数据[id].角色.数据.参战宝宝.认证码 then
      玩家数据[id].角色.数据.参战宝宝={}
      发送数据(玩家数据[id].连接id,18,玩家数据[id].角色.数据.参战宝宝)
    end
    发送数据(玩家数据[id].连接id,45,编号)
    table.remove(玩家数据[id].召唤兽.数据,编号)
    发送数据(玩家数据[id].连接id, 7, "#y/上架成功")
    for i,v in pairs(观察藏宝阁数据) do
      if 玩家数据[i] ~= nil then
        发送数据(玩家数据[i].连接id,116 , 藏宝阁数据)
      else
        观察藏宝阁数据[i] = nil
      end
    end
  end
end


function 系统处理类:藏宝阁上架(id,编号,价格) --上架手续费 第二要限制出售类型 装备类 120级以上 其他
  local 物品id = 玩家数据[id].角色.数据.道具[编号]
  local 道具类型 = 玩家数据[id].道具.数据[物品id].分类
  local 类型 = "其他"

  if 玩家数据[id].角色.数据.道具[编号] == nil then
    发送数据(玩家数据[id].连接id, 7, "#y/你没有这样的道具")
    return 0
  elseif 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]] == nil then
    发送数据(玩家数据[id].连接id, 7, "#y/出售的物品不存在")
    return 0
  elseif tonumber(价格) == nil or tonumber(价格) < 1 then
    发送数据(玩家数据[id].连接id, 7, "#y/请正确输入物品的价格")
    return 0
  elseif 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "飞行符"
    or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "摄妖香"
     or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "珍珠"
      or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "天眼通符"
        or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "金柳露"
         or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "超级金柳露"
          or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "玄武石"
           or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "青龙石"
            or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "白虎石"
             or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "朱雀石"
              or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "海马"
               or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "秘制红罗羹"
                or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "秘制绿罗羹"
                 or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "洞冥草"
                  or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "月华露"
                   or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "修炼果"
                    or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "九转金丹"
                     or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "易经丹"
                      or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "玉葫灵髓"
                       or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "清灵净瓶"
                        or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "彩果"
                         or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "金银锦盒"
                          or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "空白强化符"
                           or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "碎星锤"
                            or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "神兵图鉴"
                             or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "灵宝图鉴"
                              or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "含沙射影"
                               or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "符石卷轴"
                                or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "召唤兽内丹"
                                 or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "元宵"
                                  or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "低级清灵净瓶"
                                   or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "中级清灵净瓶"
                                    or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "百炼精铁"
                                     or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "魔兽要诀"
                                      or 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].名称 == "九转金丹"  then
        发送数据(玩家数据[id].连接id, 7, "#y/请勿上架低价值的物品")
        return 0
  elseif 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].总类 == 1 and 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].子类 == 20 then
      发送数据(玩家数据[id].连接id, 7, "#y/请勿上架低价值的物品")
       return 0
  elseif 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].总类 == 1 and 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].子类 == 1 then
      发送数据(玩家数据[id].连接id, 7, "#y/请勿上架低价值的物品")
       return 0
  elseif 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].总类 == 55 and 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].子类 == 1 then
      发送数据(玩家数据[id].连接id, 7, "#y/请勿上架低价值的物品")
       return 0
  elseif 玩家数据[id].道具.数据[物品id].总类 == 2 and 道具类型 >=1 and 道具类型 <= 6 and 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].级别限制 < 140 then
      发送数据(玩家数据[id].连接id, 7, "#y/低于140的装备属于低价值物品,无法上架藏宝阁")
      return 0
  elseif 玩家数据[id].道具.数据[物品id].总类 == 2 and 道具类型 >=10 and 道具类型 <=13 and 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]].级别限制 < 100 then
      发送数据(玩家数据[id].连接id, 7, "#y/低于100的灵饰属于低价值物品,无法上架藏宝阁")
      return 0
  else
    table.print(玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[编号]])
    if 道具类型 ~= nil then
      if 玩家数据[id].道具.数据[物品id].总类 == 2 and 道具类型 >=1 and 道具类型 <= 6 then
        类型 = "装备"
      elseif 玩家数据[id].道具.数据[物品id].总类 == 2 and 道具类型 >=10 and 道具类型 <=13 then
        类型 = "灵饰"
      end
    end
    藏宝阁数据[类型][#藏宝阁数据[类型]+1] = {物品=玩家数据[id].道具.数据[物品id],价格=价格,所有者=id,结束时间=os.time()+172800}
    玩家数据[id].角色.数据.道具[编号] = nil
    玩家数据[id].道具.数据[物品id] = nil
    道具刷新(id)
    发送数据(玩家数据[id].连接id, 7, "#y/上架成功")
    for i,v in pairs(观察藏宝阁数据) do
      if 玩家数据[i] ~= nil then
        发送数据(玩家数据[i].连接id,116 , 藏宝阁数据)
      else
        观察藏宝阁数据[i] = nil
      end
    end
  end
end
function 系统处理类:藏宝阁上架银两(id,数量,价格)
  if tonumber(数量) == nil or tonumber(价格) ==nil then
    return
  end
  if 取银子(id)<数量 then
    发送数据(玩家数据[id].连接id,7,"#y/你没那么多银子")
  elseif tonumber(价格) == nil or tonumber(价格) < 1 then
    发送数据(玩家数据[id].连接id, 7, "#y/请正确输入价格")
    return 0
  else
      玩家数据[id].角色:扣除银子(数量,0,0,"上架藏宝阁")
      藏宝阁数据["银两"][#藏宝阁数据["银两"]+1] = {数额=数量,价格=价格,所有者=id,结束时间=os.time()+86400}
      发送数据(玩家数据[id].连接id, 7, "#y/上架成功")
    for i,v in pairs(观察藏宝阁数据) do
      if 玩家数据[i] ~= nil then
        发送数据(玩家数据[i].连接id,116, 藏宝阁数据)
      else
        观察藏宝阁数据[i] = nil
      end
    end
    end
end


function 系统处理类:取消息数据(id,连接id)
  if 玩家数据[id]~=nil and 消息数据[id]~=nil and #消息数据[id]>0 then
    local 接收消息=true
    发送数据(玩家数据[id].连接id,58,{信息=消息数据[id][1].名称.."   "..消息数据[id][1].时间,模型=消息数据[id][1].模型,类型=消息数据[id][1].类型,id=消息数据[id][1].id,内容=消息数据[id][1].内容,名称=消息数据[id][1].名称,好友度=消息数据[id][1].好友度,等级=消息数据[id][1].等级})
    table.remove(消息数据[id],1)
    if #消息数据[id]==0 then
      发送数据(玩家数据[id].连接id,57,"1")
    end
    return true
  else
    发送数据(玩家数据[id].连接id,57,"1")
    return false
  end
end

function 系统处理类:拒收消息检查(id,好友id,提示id)
  if 好友黑名单[id]==nil then 好友黑名单[id]={} end
  for n=1,#好友黑名单[id] do
    if 好友黑名单[id][n]==好友id then
      常规提示(提示id,"#Y你已被对方拉入黑名单中！")
      return false
    end
  end
  return true
end

function 系统处理类:更新消息通知(id)
  if 玩家数据[id]~=nil and 消息数据[id]~=nil and #消息数据[id]>0  then
    发送数据(玩家数据[id].连接id,56,"1")
  end
  if 玩家数据[id]~=nil and 玩家数据[id].摊位数据~=nil then
    玩家数据[id].摊位数据=nil
    地图处理类:取消玩家摊位(id)
  end
end

function 系统处理类:取好友度(id,好友id)
  for n=1,#玩家数据[id].角色.数据.好友数据.好友 do
    if 玩家数据[id].角色.数据.好友数据.好友[n].id==好友id then
      if 玩家数据[id].角色.数据.好友数据.好友[n].好友度==nil then
        return 0
      else
        return 玩家数据[id].角色.数据.好友数据.好友[n].好友度
      end
    end
  end
  return 0
end

function 系统处理类:添加好友(id,连接id,好友id,类型)
  if id==好友id then
    常规提示(id,"#Y你无法将自己添加到好友名单中")
    return
  end
  if 类型==1 then
    if #玩家数据[id].角色.数据.好友数据.好友>=50 then
      常规提示(id,"#Y你的好友人数已达上限")
      return
    else
      --检查是否重复
      for n=1,#玩家数据[id].角色.数据.好友数据.好友 do
        if 玩家数据[id].角色.数据.好友数据.好友[n].id==好友id then
          常规提示(id,"#Y对方已经在你的好友名单中了")
          return
        end
      end
      local 删除序列=0
      for n=1,#玩家数据[id].角色.数据.好友数据.黑名单 do
        if 玩家数据[id].角色.数据.好友数据.黑名单[n].id==好友id then
          删除序列=n
        end
      end
      if 删除序列~=0 then
        table.remove(玩家数据[id].角色.数据.好友数据.黑名单,删除序列)
      end
      --增加新朋友
    end
    玩家数据[id].角色.数据.好友数据.好友[#玩家数据[id].角色.数据.好友数据.好友+1]={关系="陌生人",模型=玩家数据[好友id].角色.数据.模型,名称=玩家数据[好友id].角色.数据.名称,id=好友id,门派=玩家数据[好友id].角色.数据.门派,帮派=玩家数据[好友id].角色.数据.帮派,等级=玩家数据[好友id].角色.数据.等级,称谓=玩家数据[好友id].角色.数据.当前称谓}
    for n=1,#玩家数据[好友id].角色.数据.好友数据.好友 do
      if 玩家数据[好友id].角色.数据.好友数据.好友[n].id==id then
        if 玩家数据[好友id].角色.数据.好友数据.好友[n].好友度~=nil then
          玩家数据[id].角色.数据.好友数据.好友[#玩家数据[id].角色.数据.好友数据.好友].好友度=玩家数据[好友id].角色.数据.好友数据.好友[n].好友度
        end
        玩家数据[好友id].角色.数据.好友数据.好友[n].关系="普通朋友"
        玩家数据[id].角色.数据.好友数据.好友[#玩家数据[id].角色.数据.好友数据.好友].关系="普通朋友"
      end
    end
    常规提示(id,"#Y添加好友成功")
    常规提示(好友id,"#Y"..玩家数据[id].角色.数据.名称.."将你添加为好友")
    local 删除序列=0
    for n=1,#玩家数据[id].角色.数据.好友数据.临时 do
      if 玩家数据[id].角色.数据.好友数据.临时[n].id==好友id then
        删除序列=n
      end
    end
    if 删除序列~=0 then
      table.remove(玩家数据[id].角色.数据.好友数据.临时,删除序列)
    end
    发送数据(连接id,52)
    if 玩家数据[id].角色.数据.好友数据.好友[#玩家数据[id].角色.数据.好友数据.好友].关系~="陌生人" then
      发送数据(玩家数据[好友id].连接id,52)
    end
  elseif 类型==2 then  --加为临时
    for n=1,#玩家数据[id].角色.数据.好友数据.好友 do
      if 玩家数据[id].角色.数据.好友数据.好友[n].id==好友id then
        常规提示(id,"#Y对方已经在你的好友名单中了")
        return
      end
    end
    for n=1,#玩家数据[id].角色.数据.好友数据.临时 do
      if 玩家数据[id].角色.数据.好友数据.临时[n].id==好友id then
        常规提示(id,"#Y对方已经在你的临时好友名单中了")
        return
      end
    end
    local 序列=0
    if #玩家数据[id].角色.数据.好友数据.临时<6 then
      序列=#玩家数据[id].角色.数据.好友数据.临时+1
    else
      table.remove(玩家数据[id].角色.数据.好友数据.临时,1)
      序列=6
    end
    玩家数据[id].角色.数据.好友数据.临时[序列]={关系="陌生人",模型=玩家数据[好友id].角色.数据.模型,名称=玩家数据[好友id].角色.数据.名称,id=好友id,门派=玩家数据[好友id].角色.数据.门派,帮派=玩家数据[好友id].角色.数据.帮派,等级=玩家数据[好友id].角色.数据.等级,称谓=玩家数据[好友id].角色.数据.当前称谓}
    常规提示(id,"#Y添加临时好友成功")
    发送数据(连接id,52)
  elseif 类型==3 then  --加为临时
    for n=1,#玩家数据[id].角色.数据.好友数据.黑名单 do
      if 玩家数据[id].角色.数据.好友数据.黑名单[n].id==好友id then
        常规提示(id,"#Y对方已经在你的黑名单中了")
        return
      end
    end
    if #玩家数据[id].角色.数据.好友数据.黑名单>=20 then
      常规提示(id,"#Y你的黑名单人数已达上限")
      return
    end
    玩家数据[id].角色.数据.好友数据.黑名单[#玩家数据[id].角色.数据.好友数据.黑名单+1]={关系="黑名单",模型=玩家数据[好友id].角色.数据.模型,名称=玩家数据[好友id].角色.数据.名称,id=好友id,门派=玩家数据[好友id].角色.数据.门派,帮派=玩家数据[好友id].角色.数据.帮派,等级=玩家数据[好友id].角色.数据.等级,称谓=玩家数据[好友id].角色.数据.当前称谓}
    好友黑名单[id][#好友黑名单[id]+1]=好友id
    常规提示(id,"#Y添加黑名单成功")
    local 删除序列=0
    for n=1,#玩家数据[id].角色.数据.好友数据.好友 do
      if 玩家数据[id].角色.数据.好友数据.好友[n].id==好友id then
        删除序列=n
      end
    end
    if 删除序列~=0 then
      table.remove(玩家数据[id].角色.数据.好友数据.好友,删除序列)
    end
    删除序列=0
    for n=1,#玩家数据[id].角色.数据.好友数据.临时 do
      if 玩家数据[id].角色.数据.好友数据.临时[n].id==好友id then
        删除序列=n
      end
    end
    if 删除序列~=0 then
      table.remove(玩家数据[id].角色.数据.好友数据.临时,删除序列)
    end
    删除序列=0
    for n=1,#玩家数据[id].角色.数据.好友数据.最近 do
      if 玩家数据[id].角色.数据.好友数据.最近[n].id==好友id then
        删除序列=n
      end
    end
    if 删除序列~=0 then
      table.remove(玩家数据[id].角色.数据.好友数据.最近,删除序列)
    end
    发送数据(连接id,52)
  end
end

function 系统处理类:查找角色(名称,id)
  local 数据组={}
  if id~="" then id=id+0 end
  for i, v in pairs(玩家数据) do
    if 玩家数据[i].管理==nil and 玩家数据[i].角色.数据.名称==名称 or i==id then
      数据组[1]=玩家数据[i].角色.数据.名称
      数据组[2]=i
      数据组[3]=玩家数据[i].角色.数据.等级
      数据组[4]=玩家数据[i].角色.数据.门派
    end
  end
  return 数据组
end

function 系统处理类:断开游戏(id,连接id,数字id)
  __gge.print(false,6,时间转换(os.time()).."     玩家 ")
  __gge.print(false,11,玩家数据[id].角色.数据.名称)
  __gge.print(false,12," 退出游戏\n")
  if 玩家数据[数字id] == nil then
    return
  end
  if 玩家数据[数字id].摊位数据~=nil then
    return
  end
  if 玩家数据[数字id].管理~=nil then
    玩家数据[数字id] = nil
    return
  end
  if 玩家数据[数字id]~=nil and 玩家数据[数字id].战斗~=0 then
    if 战斗准备类.战斗盒子[玩家数据[数字id].战斗]~=nil and 玩家数据[数字id].观战 == nil then
      战斗准备类.战斗盒子[玩家数据[数字id].战斗]:设置断线玩家(数字id)
      return
    elseif 战斗准备类.战斗盒子[玩家数据[数字id].战斗]~=nil and 玩家数据[数字id].观战 ~= nil then
      战斗准备类.战斗盒子[玩家数据[数字id].战斗][数字id] = nil
      玩家数据[数字id].战斗=0
    else
      玩家数据[数字id].战斗=0
    end
  end
  if 玩家数据[数字id]~=nil  then
    if 玩家数据[数字id].交易信息~=nil then
      玩家数据[数字id].道具:取消交易(数字id)
    end
    if 玩家数据[数字id].队伍~=0 then
      队伍处理类:退出队伍(数字id)
    end
    if 自动遇怪[数字id]~=nil then
      自动遇怪[数字id]=nil
    end
    if 玩家数据[数字id].角色.数据.帮派 ~= "无帮派" and 玩家数据[数字id].角色.数据.帮派数据 ~= nil then
      local 帮派编号 = 玩家数据[数字id].角色.数据.帮派数据.编号
      if 帮派数据[帮派编号].商人 == nil then 帮派数据[帮派编号].商人 = {} end
      if 帮派数据[帮派编号].成员数据[数字id] ~= nil and 帮派数据[帮派编号].成员数据[数字id].职务 == "商人" then
        for i=1,#帮派数据[帮派编号].商人 do
          if 帮派数据[帮派编号].商人[i] ~= nil and 帮派数据[帮派编号].商人[i].id == 数字id then
            table.remove(帮派数据[帮派编号].商人,i)
            break
          end
        end
        帮派数据[帮派编号].成员数据[数字id].职务 =  "帮众"
        玩家数据[数字id].角色:删除称谓(数字id,帮派数据[帮派编号].帮派名称.."商人")
        玩家数据[数字id].角色:添加称谓(数字id,帮派数据[帮派编号].帮派名称.."帮众")
      end
      帮派数据[帮派编号].成员数据[数字id].在线 = false
      帮派数据[帮派编号].成员数据[数字id].离线时间 = os.time()
    end
    玩家数据[数字id].角色:存档()
    if 玩家数据[数字id].账号 == nil then
        玩家数据[数字id].账号 = 玩家数据[数字id].角色.数据.账号
        账号记录[玩家数据[数字id].账号..数字id]=nil
    else
      账号记录[玩家数据[数字id].账号..数字id]=nil --退出游戏
    end
    地图处理类:移除玩家(数字id)
    玩家数据[数字id]=nil
    collectgarbage("collect")
  end
end
function 系统处理类:统计排行榜(id,刷新1)
  local 名单={实力={},比武={},帮派={},财富={银子={},金额={}},天梯={}}
  local 我的排行={实力={},比武={},帮派={},财富={银子={},金额={}},天梯={}}
  local 发送信息 = {实力={},比武={},帮派={},财富={银子={},金额={}},天梯={}}
  for b, v in pairs(经验数据.排行) do
    名单["实力"][#名单["实力"]+1]={经验=经验数据.排行[b].经验,id=b,名称=经验数据.排行[b].名称,等级=经验数据.排行[b].等级,门派=经验数据.排行[b].门派,账号=经验数据.排行[b].账号}
  end
  table.sort(名单["实力"],function(a,b) return a.经验>b.经验 end )
  发送信息.比武=比武大会
  for b, v in pairs(银子数据) do
    名单["财富"]["银子"][#名单["财富"]["银子"]+1]={银子=银子数据[b].银子,id=b,名称=银子数据[b].名称,等级=银子数据[b].等级,门派=银子数据[b].门派,账号=银子数据[b].账号}
  end
  table.sort(名单["财富"]["银子"],function(a,b) return a.银子>b.银子 end )
  for b, v in pairs(充值数据) do
    名单["财富"]["金额"][#名单["财富"]["金额"]+1]={金额=充值数据[b].金额,id=b,名称=充值数据[b].名称,等级=充值数据[b].等级,门派=充值数据[b].门派,账号=充值数据[b].账号}
  end
  table.sort(名单["财富"]["金额"],function(a,b) return a.金额>b.金额 end )
  for b, v in pairs(帮派竞赛) do
    名单["帮派"][#名单["帮派"]+1]={帮派=帮派竞赛[b].帮派名称,id=b,帮主=帮派竞赛[b].帮主,id=帮派竞赛[b].id,积分=帮派竞赛[b].积分}
  end
  table.sort(名单["帮派"],function(a,b) return a.积分>b.积分 end )
  -------------------------------
  for b, v in pairs(天梯数据.玩家信息) do
    名单["天梯"][#名单["天梯"]+1]={名称=天梯数据.玩家信息[b].名称,id=b,积分=天梯数据.玩家信息[b].积分}
  end
  table.sort(名单["天梯"],function(a,b) return a.积分>b.积分 end )
  ---------------------------
  -- local 主,客,主键值,客键值
  -- for k,v in pairs(天梯数据.匹配池) do
  --     if 天梯数据.匹配池[k].匹配者 ~= nil then
  --        --天梯数据["战斗池"][#天梯数据["战斗池"]+1]= {主=天梯数据.匹配池[k].匹配者}
  --        主=天梯数据.匹配池[k].匹配者
  --        主键值=天梯数据.匹配池[k]
  --           for i,v in pairs(天梯数据.匹配池) do
  --             if 主 ~= nil and 主 ~= 天梯数据.匹配池[i].匹配者 then
  --               客=天梯数据.匹配池[i].匹配者
  --               客键值=天梯数据.匹配池[i]
  --               天梯数据["战斗池"][#天梯数据["战斗池"]+1]= {主=主,客=客}
  --                for z,v in pairs(天梯数据.匹配池) do
  --                   if 主==天梯数据.匹配池[z].匹配者 then
  --                    table.remove(天梯数据.匹配池,z)
  --                    天梯数据.玩家信息[主].匹配=false
  --                   end
  --                end
  --                for c,v in pairs(天梯数据.匹配池) do
  --                   if 客==天梯数据.匹配池[c].匹配者 then
  --                    table.remove(天梯数据.匹配池,c)
  --                    天梯数据.玩家信息[客].匹配=false
  --                   end
  --                end

  --             end
  --           end
  --     end
  -- end
  ------------------------
  for i=1,10 do
    if 名单["实力"][i] ~= nil then
      发送信息.实力[i] = 名单["实力"][i]
    end
    if 名单["比武"][i] ~= nil then
      发送信息.比武[i] = 名单["比武"][i]
    end
    if 名单["帮派"][i] ~= nil then
      发送信息.帮派[i] = 名单["帮派"][i]
    end
    if 名单["财富"]["银子"][i] ~= nil then
      发送信息.财富.银子[i] = 名单["财富"]["银子"][i]
    end
    if 名单["财富"]["金额"][i] ~= nil then
      发送信息.财富.金额[i] = 名单["财富"]["金额"][i]
    end
    if 名单["天梯"][i] ~= nil then
      发送信息.天梯[i] = 名单["天梯"][i]
    end
  end
  发送信息.id = id
  发送数据(玩家数据[id].连接id,49,发送信息)
end

function 系统处理类:进入游戏(id,账号,数字id,ip,序号)
  if 序号 == 4.2 then
    数字id=数字id+0
    __C客户信息[id].角色id = 数字id
    __C客户信息[id].jb=2
    玩家数据[数字id]={连接id=id}
    玩家数据[数字id].角色=角色处理类:创建(id)
    玩家数据[数字id].道具=道具处理类:创建(id)
    玩家数据[数字id].装备=装备处理类:创建(id,数字id)
    玩家数据[数字id].召唤兽=召唤兽处理类:创建(id,数字id)
    玩家数据[数字id].账号=账号
    玩家数据[数字id].ip=ip
    玩家数据[数字id].管理 = true
    发送数据(玩家数据[数字id].连接id,10086)
 else
    数字id=数字id+0
    if 消息数据[数字id]==nil then
      消息数据[数字id]={}
    end
    if 好友黑名单[数字id]==nil then
      好友黑名单[数字id]={}
    end
    __C客户信息[id].角色id = 数字id
    __C客户信息[id].jb=2
    if 玩家数据[数字id] ~= nil and 玩家数据[数字id].角色 ~= nil and 玩家数据[数字id].角色.数据.藏宝阁出售 == nil then
      if 玩家数据[数字id].交易信息~=nil then
        玩家数据[数字id].道具:取消交易(数字id)
      end
      __C客户信息[玩家数据[数字id].连接id]=nil
      发送数据(玩家数据[数字id].连接id,998,"您的账号已经在其他地方登陆,如不是您本人,请及时修改密码")
      __S服务:断开连接(玩家数据[数字id].连接id)
      玩家数据[数字id].连接id=id
      if 玩家数据[数字id].角色.数据.地图数据.编号 >=1340 and 玩家数据[数字id].角色.数据.地图数据.编号 <=1342 then
        local x = tonumber(string.sub(玩家数据[数字id].角色.数据.地图数据.编号,1,7))
        for i=1,#房屋数据 do
          if 房屋数据[i].ID == x then
            发送数据(id,111,房屋数据[i])
          end
        end
      end
      if 序号 == nil then
        发送数据(id,5,玩家数据[数字id].角色:取总数据())
        发送数据(id,16,玩家数据[数字id].召唤兽.数据)
        发送数据(id,102,玩家数据[数字id].助战:取数据())
        玩家数据[数字id].角色:刷新任务跟踪()
      end
      发送数据(id,43,{时辰=时辰信息.当前})
      地图处理类:重连加入(数字id,玩家数据[数字id].角色.数据.地图数据.编号,玩家数据[数字id].角色.数据.地图数据.x,玩家数据[数字id].角色.数据.地图数据.y)
      self:更新消息通知(数字id)
      if 玩家数据[数字id].战斗 ~= 0 and 战斗准备类.战斗盒子[玩家数据[数字id].战斗]==nil then
        玩家数据[数字id].战斗=0
        发送数据(玩家数据[数字id].连接id,5505)
        玩家数据[数字id].遇怪时间=os.time()+取随机数(5,10)
        玩家数据[数字id].道具:重置法宝回合(数字id)
        玩家数据[数字id].角色.数据.战斗开关=nil
      end
      if 玩家数据[数字id].战斗==0 then
        if 玩家数据[数字id].队伍~=0 then
          队伍处理类:退出队伍(数字id)
        end
      else
        if 玩家数据[数字id].队伍~=0 then
          队伍处理类:索取队伍信息(数字id,4004)
          if 玩家数据[数字id].队长 then
            发送数据(玩家数据[数字id].连接id,4006)
          end
        end
        if 序号 == nil then
          战斗准备类.战斗盒子[玩家数据[数字id].战斗]:设置重连玩家(数字id)
        else
          战斗准备类.战斗盒子[玩家数据[数字id].战斗]:设置断线重连(数字id)
        end
      end
    else
        if 账号记录 == nil then
          return
        end
        账号记录[账号..数字id]=数字id
        玩家数据[数字id]={连接id=id}
        玩家数据[数字id].角色=角色处理类:创建(id)
        玩家数据[数字id].道具=道具处理类:创建(id)
        玩家数据[数字id].装备=装备处理类:创建(id,数字id)
        玩家数据[数字id].召唤兽=召唤兽处理类:创建(id,数字id)
        玩家数据[数字id].助战=助战处理类:创建(数字id)
        玩家数据[数字id].角色:加载数据(账号,数字id)
        if 玩家数据[数字id].角色.数据.藏宝阁出售 ~= nil then
          常规提示(数字id,"#Y该角色已经被上架藏宝阁,无法进入游戏,可以使用任意角色在XX处使用ID和取回密码取回账号")
          return
        end
        玩家数据[数字id].道具:加载数据(账号,数字id)
        玩家数据[数字id].召唤兽:加载数据(账号,数字id)
        玩家数据[数字id].助战:加载数据(账号,数字id)
        玩家数据[数字id].账号=账号
        玩家数据[数字id].队伍=0
        玩家数据[数字id].当前频道=os.time()
        玩家数据[数字id].世界频道=os.time()
        玩家数据[数字id].传闻频道=os.time()
        玩家数据[数字id].遇怪时间=os.time()+取随机数(10,20)
        玩家数据[数字id].战斗=0
        玩家数据[数字id].ip=ip
        玩家数据[数字id].连接id=id
        玩家数据[数字id].商品列表=0
        玩家数据[数字id].移动数据={}
        玩家数据[数字id].最后事件=""
        玩家数据[数字id].道具操作={}
        f函数.写配置(程序目录..[[data\]]..账号..[[\账号信息.txt]],"账号配置","创建ip",ip)
         if 天梯数据.玩家信息[数字id]==nil then
          天梯数据.玩家信息[数字id]={单人匹配=false,三人匹配=false,五人匹配=false,匹配中=false,积分=1000,段位进度=1,连胜次数=0,角色id=数字id,名称=玩家数据[数字id].角色.数据.名称,账号=账号}
          常规提示(id,"#Y少年你还没开启过天梯竞技？赶快奋斗吧！")
       end
          if 玩家数据[数字id].角色.数据.地图数据.编号 >=1340 and 玩家数据[数字id].角色.数据.地图数据.编号 <=1342 then
          local x = tonumber(string.sub(玩家数据[数字id].角色.数据.地图数据.编号,1,7))
          for i=1,#房屋数据 do
            if 房屋数据[i].ID == x then
              发送数据(id,111,房屋数据[i])
            end
          end
        end




        if 玩家数据[数字id].角色.数据.地图数据.编号>=1600 and 玩家数据[数字id].角色.数据.地图数据.编号<=1620 and 迷宫数据.开关==false then
          玩家数据[数字id].角色.数据.地图数据.编号=1092
          玩家数据[数字id].角色.数据.地图数据.x=199*20
          玩家数据[数字id].角色.数据.地图数据.y=17*20
        elseif 玩家数据[数字id].角色.数据.地图数据.编号>=6003 and 玩家数据[数字id].角色.数据.地图数据.编号<=6008 then
          玩家数据[数字id].角色.数据.地图数据.编号=1092
          玩家数据[数字id].角色.数据.地图数据.x=124*20
          玩家数据[数字id].角色.数据.地图数据.y=174*20
        elseif 玩家数据[数字id].角色.数据.地图数据.编号==5001 then
          玩家数据[数字id].角色.数据.地图数据.编号=1226
          玩家数据[数字id].角色.数据.地图数据.x=115*20
          玩家数据[数字id].角色.数据.地图数据.y=15*20
        elseif 玩家数据[数字id].角色.数据.地图数据.编号>=6021 and 玩家数据[数字id].角色.数据.地图数据.编号<=6023 and (玩家数据[数字id].角色:取任务(130) == nil or 玩家数据[数字id].角色:取任务(130) == 0 or 任务数据[玩家数据[数字id].角色:取任务(130)]==nil) then
          玩家数据[数字id].角色.数据.地图数据.编号=1070
          玩家数据[数字id].角色.数据.地图数据.x=125*20
          玩家数据[数字id].角色.数据.地图数据.y=144*20
        elseif 玩家数据[数字id].角色.数据.地图数据.编号>=6001 and 玩家数据[数字id].角色.数据.地图数据.编号<=6002 and (玩家数据[数字id].角色:取任务(120) == nil or 玩家数据[数字id].角色:取任务(120) == 0 or 任务数据[玩家数据[数字id].角色:取任务(120)]==nil) then
          玩家数据[数字id].角色.数据.地图数据.编号=1001
          玩家数据[数字id].角色.数据.地图数据.x=287*20
          玩家数据[数字id].角色.数据.地图数据.y=85*20
        elseif 玩家数据[数字id].角色.数据.地图数据.编号>=6024 and 玩家数据[数字id].角色.数据.地图数据.编号<=6026 and (玩家数据[数字id].角色:取任务(120) == nil or 玩家数据[数字id].角色:取任务(120) == 0 or 任务数据[玩家数据[数字id].角色:取任务(120)]==nil) then
          玩家数据[数字id].角色.数据.地图数据.编号=1002
          玩家数据[数字id].角色.数据.地图数据.x=34*20
          玩家数据[数字id].角色.数据.地图数据.y=71*20
        elseif 玩家数据[数字id].角色.数据.地图数据.编号>=6027 and 玩家数据[数字id].角色.数据.地图数据.编号<=6030 and (玩家数据[数字id].角色:取任务(160) == nil or 玩家数据[数字id].角色:取任务(160) == 0 or 任务数据[玩家数据[数字id].角色:取任务(160)]==nil) then
          玩家数据[数字id].角色.数据.地图数据.编号=1070
          玩家数据[数字id].角色.数据.地图数据.x=53*20
          玩家数据[数字id].角色.数据.地图数据.y=70*20


        end
if 玩家数据[数字id].角色.数据.地图数据.编号 >= 4000000  and 玩家数据[数字id].角色.数据.地图数据.编号 <= 400000000 then
       玩家数据[数字id].角色.数据.地图数据.编号=1001
       玩家数据[数字id].角色.数据.地图数据.x=237*20
       玩家数据[数字id].角色.数据.地图数据.y=114*20
      -- local x = tonumber(string.sub(玩家数据[数字id].角色.地图数据.编号,1,7))
      -- for i=1,#房屋数据 do
      --   if 房屋数据[i].ID == x then
      --   发送数据(id,101,房屋数据[i])
      --   end
      -- end
    end
if 玩家数据[数字id].角色.数据.地图数据.编号 >= 4000000  and 玩家数据[数字id].角色.数据.地图数据.编号 <= 400000000 then
      local x = tonumber(string.sub(玩家数据[数字id].角色.数据.地图数据.编号,1,7))
      for i=1,#房屋数据 do
        if 房屋数据[i].ID == x then
          发送数据(id,111,房屋数据[i])
        end
      end
    end



        if 银子数据[数字id]==nil then
          银子数据[数字id]={id=数字id,名称=玩家数据[数字id].角色.数据.名称,银子=玩家数据[数字id].角色.数据.银子+玩家数据[数字id].角色.数据.存银,门派=玩家数据[数字id].角色.数据.门派,等级=玩家数据[数字id].角色.数据.等级}
        end
        if 活跃数据[数字id]==nil then
          活跃数据[数字id]={活跃度=0,领取100活跃=false,领取200活跃=false,领取300活跃=false,领取400活跃=false,领取500活跃=false,师门次数=20,官职次数=30,鬼怪次数=25,封妖次数=3,游泳次数=1,镖王次数=1,押镖次数=50,水果次数=25,天庭叛逆次数=25,十二星宿次数=5,门派闯关次数=1,地煞星次数=5,天罡星次数=5,飞贼次数=5,知了先锋=20,小知了王=20,知了王=10,世界BOSS次数=2,抓鬼次数=50,初出江湖次数=20,帮派青龙次数=100,帮派玄武次数=100,妖王次数=3}
        end
      --发送角色数据
      if 玩家数据[数字id].角色.数据.帮派 ~= "无帮派" and (玩家数据[数字id].角色.数据.帮派数据 == nil or 帮派数据[玩家数据[数字id].角色.数据.帮派数据.编号] == nil or 帮派数据[玩家数据[数字id].角色.数据.帮派数据.编号].成员数据[数字id] == nil) then
        玩家数据[数字id].角色.数据.帮派 = "无帮派"
        玩家数据[数字id].角色.数据.帮派数据 = nil
        发送数据(数字id,7,"#R你已经被逐出了帮派")
      elseif 玩家数据[数字id].角色.数据.帮派 ~= "无帮派" and 玩家数据[数字id].角色.数据.帮派数据 ~= nil and 帮派数据[玩家数据[数字id].角色.数据.帮派数据.编号] ~= nil and 帮派数据[玩家数据[数字id].角色.数据.帮派数据.编号].成员数据[数字id] ~= nil then
        帮派数据[玩家数据[数字id].角色.数据.帮派数据.编号].成员数据[数字id].在线 = true
      end
      for i,v in pairs(玩家数据[数字id].角色.数据.装备) do
        if v ~= nil and 玩家数据[数字id].道具.数据[v] ~= nil and 玩家数据[数字id].道具.数据[v].临时附魔 ~= nil then
          玩家数据[数字id].角色:附魔装备刷新(数字id,v)
        end
      end
      发送数据(id,5,玩家数据[数字id].角色:取总数据())
      local 玩家门派 = 玩家数据[数字id].角色.数据.门派
      for i=1,#玩家数据[数字id].角色.数据.称谓 do
        if 玩家门派 ~= nil and 玩家数据[数字id].角色.数据.称谓[i] == 玩家门派.."首席大弟子" and 首席争霸[玩家门派] ~= nil and 首席争霸[玩家门派].id ~= nil and 首席争霸[玩家门派].id ~= 数字id then
          玩家数据[数字id].角色:删除称谓(数字id,玩家门派.."首席大弟子")
          break
        end
      end
      广播消息({内容=format("#Y玩家#G/%s#Y上线了！欢迎您#"..取随机数(1,110),玩家数据[数字id].角色.数据.名称),频道="xt"})
      发送数据(id,16,玩家数据[数字id].召唤兽.数据)
      发送数据(id,102,玩家数据[数字id].助战:取数据())
      发送数据(id,1,{id=id,用户="正式用户"})
      发送数据(id,43,{时辰=时辰信息.当前})
      地图处理类:加入玩家(数字id,玩家数据[数字id].角色.数据.地图数据.编号,玩家数据[数字id].角色.数据.地图数据.x,玩家数据[数字id].角色.数据.地图数据.y)
      玩家数据[数字id].角色:刷新任务跟踪()
      self:更新消息通知(数字id)
      if 玩家数据[数字id].角色.数据.强P开关 ~= nil then
        发送数据(id,94,{开关=true})
        地图处理类:更改强PK(数字id,true)
      elseif 玩家数据[数字id].角色.数据.PK开关 ~= nil then
        发送数据(id,93,{开关=true})
        地图处理类:更改PK(数字id,true)
      end
      if 释怀定制 then
        local 点卡=f函数.读配置(程序目录..[[data\]]..玩家数据[数字id].账号..[[\账号信息.txt]],"账号配置","点卡")
        if 点卡==nil or 点卡=="空" then
            f函数.写配置(程序目录..[[data\]]..玩家数据[数字id].账号..[[\账号信息.txt]],"账号配置","点卡","0")
        end
      end
      if 老八定制 or 专属定制 then
        if 新手活动[数字id]==nil then
          新手活动[数字id]={次数=0}
        end
      end
      if 玩家数据[数字id].角色.数据.剧情.飞升==nil then
          玩家数据[数字id].角色.数据.修炼.攻击修炼[3]=math.floor(取人物修炼等级上限(玩家数据[数字id].角色.数据.等级))
          玩家数据[数字id].角色.数据.修炼.防御修炼[3]=math.floor(取人物修炼等级上限(玩家数据[数字id].角色.数据.等级))
          玩家数据[数字id].角色.数据.修炼.法术修炼[3]=math.floor(取人物修炼等级上限(玩家数据[数字id].角色.数据.等级))
          玩家数据[数字id].角色.数据.修炼.抗法修炼[3]=math.floor(取人物修炼等级上限(玩家数据[数字id].角色.数据.等级))
          玩家数据[数字id].角色.数据.修炼.猎术修炼[3]=math.floor(取人物修炼等级上限(玩家数据[数字id].角色.数据.等级))
          玩家数据[数字id].角色.数据.bb修炼.攻击控制力[3]=math.floor(取人物修炼等级上限(玩家数据[数字id].角色.数据.等级))
          玩家数据[数字id].角色.数据.bb修炼.防御控制力[3]=math.floor(取人物修炼等级上限(玩家数据[数字id].角色.数据.等级))
          玩家数据[数字id].角色.数据.bb修炼.法术控制力[3]=math.floor(取人物修炼等级上限(玩家数据[数字id].角色.数据.等级))
          玩家数据[数字id].角色.数据.bb修炼.抗法控制力[3]=math.floor(取人物修炼等级上限(玩家数据[数字id].角色.数据.等级))
      end

      if 玩家数据[数字id].角色.数据.等级 >50 and 玩家数据[数字id].角色.数据.新手银子 ~= nil then
        玩家数据[数字id].角色.数据.新手银子 = nil
      end
      if 玩家数据[数字id].角色.数据.等级>=69 then
          玩家数据[数字id].角色.数据.装备属性.可换乾元丹=1
      end
      if 玩家数据[数字id].角色.数据.等级>=89 then
          玩家数据[数字id].角色.数据.装备属性.可换乾元丹=2
      end
      if 玩家数据[数字id].角色.数据.等级>=109 then
          玩家数据[数字id].角色.数据.装备属性.可换乾元丹=3
      end
      if 玩家数据[数字id].角色.数据.等级>=129 then
          玩家数据[数字id].角色.数据.装备属性.可换乾元丹=4
      end
      if 玩家数据[数字id].角色.数据.等级>=155 then
          玩家数据[数字id].角色.数据.装备属性.可换乾元丹=5
      end
      if 玩家数据[数字id].角色.数据.等级>=159 then
          玩家数据[数字id].角色.数据.装备属性.可换乾元丹=6
      end
      if 玩家数据[数字id].角色.数据.等级>=164 then
          玩家数据[数字id].角色.数据.装备属性.可换乾元丹=7
      end
      if 玩家数据[数字id].角色.数据.等级>=168 then
          玩家数据[数字id].角色.数据.装备属性.可换乾元丹=8
      end
      if 玩家数据[数字id].角色.数据.等级>=171 then
          玩家数据[数字id].角色.数据.装备属性.可换乾元丹=9
      end

      if 玩家数据[数字id].角色.数据.比武积分==nil or 玩家数据[数字id].角色.数据.比武积分==0 then
          玩家数据[数字id].角色.数据.比武积分={当前积分=0,总积分=0}
      end
      --if  玩家数据[数字id].角色.数据.战斗加速==nil  then
      --    玩家数据[数字id].角色.数据.战斗加速=0
      --end
      if  玩家数据[数字id].角色.数据.单人闯关==nil  then
          玩家数据[数字id].角色.数据.单人闯关=0
      end
      if  玩家数据[数字id].角色.数据.坐骑隐藏==nil  then
          玩家数据[数字id].角色.数据.坐骑隐藏=0
      end
      if  玩家数据[数字id].角色.数据.锦衣隐藏==nil  then
          玩家数据[数字id].角色.数据.锦衣隐藏=0
      end
      if  玩家数据[数字id].角色.数据.坐骑隐藏==1  then
          发送数据(玩家数据[数字id].连接id,60.3,玩家数据[数字id].角色.数据.坐骑)
      end
      if  玩家数据[数字id].角色.数据.锦衣隐藏==1  then
          发送数据(玩家数据[数字id].连接id,60.4,1)
      end

      if  玩家数据[数字id].角色.数据.强化技能[11].等级~=nil  then
          发送数据(玩家数据[数字id].连接id,60.2,玩家数据[数字id].角色.数据.强化技能[11].等级)
      end

        玩家数据[数字id].角色.数据.自动挂机=0
        玩家数据[数字id].角色.数据.自动遇怪时间=os.time()
      if  玩家数据[数字id].角色.数据.坐骑~=nil  then
        --  玩家数据[数字id].角色.数据.坐骑=table.loadstring(table.tostring(玩家数据[数字id].角色.数据.坐骑列表[序列]))
        --  发送数据(玩家数据[数字id].连接id,60,玩家数据[数字id].角色.数据.坐骑)
          发送数据(玩家数据[数字id].连接id,60.1,玩家数据[数字id].角色.数据.坐骑.修炼.速度修炼[1])
      end
      if 玩家数据[数字id].角色.数据.累积活跃==nil then
          玩家数据[数字id].角色.数据.累积活跃={当前积分=0,总积分=0}
      end

      if VIP定制 then
        if VIP数据[数字id]==nil then
          VIP数据[数字id] = {}
          VIP数据[数字id].VIP经验 = 0
          VIP数据[数字id].VIP1状态 = false
          VIP数据[数字id].VIP2状态 = false
          VIP数据[数字id].VIP3状态 = false
          VIP数据[数字id].VIP4状态 = false
          VIP数据[数字id].VIP5状态 = false
        end
      end
      if 梦幻粉 or 风雨无言定制 then
        十二生肖[数字id]={子鼠=false,丑牛=false,寅虎=false,卯兔=false,辰龙=false,巳蛇=false,午马=false,未羊=false,神猴=false,酉鸡=false,戌狗=false,亥猪=false}
      end
      self.找到节日=false
      for n=1,52 do
        self.当前时间=os.date("%m月%d日")
        self.节日时间=f函数.读配置(程序目录.."Shopping.ini","节日时间","节日时间"..n)
        self.节日名称=f函数.读配置(程序目录.."Shopping.ini","节日名称","节日名称"..n)
        if self.当前时间==self.节日时间 then
          常规提示(数字id,"今天是#R/"..self.节日名称.."#W/，请前往长安节日礼物使者#Y/（208，152）#W/处领取节日礼物，祝您天天有个好心情！#77")
          self.找到节日=true
          break
        end
      end
      if self.找到节日 then
          节日开关=true
      else
          节日开关=false
      end
      if f函数.读配置(程序目录..[[data\]]..账号..[[\账号信息.txt]],"账号配置","安全码")=="0" then
        local 对话=[[您的账号尚未设置安全码，请在聊天框内输入安全码+你要设置的安全码以完成安全码设置操作。如使用#R123456#W为安全码，直接在聊天频道内输入#R安全码123456#W即可。该条消息不会被推送至聊天频道。安全码由6位数字组成，是判定账号归属者的唯一认定。]]
        发送数据(玩家数据[数字id].连接id,1501,{名称=玩家数据[数字id].角色.数据.名称,模型=玩家数据[数字id].角色.数据.模型,对话=对话,选项=选项})
      end
      发送数据(玩家数据[数字id].连接id,5505)
    end
    if 玩家数据[数字id]~=nil then
      玩家数据[数字id].角色.数据.战斗开关=nil
      self:进入事件(数字id,玩家数据[数字id].连接id)
    end
  end
end

function 系统处理类:进入事件(id,连接id,ID,IP,PORT)
  __gge.print(false,6,时间转换(os.time()).."     玩家 ")
  __gge.print(false,11,玩家数据[id].角色.数据.名称)
  __gge.print(false,10," 进入游戏\n")
  for n=1,#玩家数据[id].角色.数据.好友数据.好友 do
    local 好友id=玩家数据[id].角色.数据.好友数据.好友[n].id
    if 玩家数据[好友id]~=nil and 玩家数据[id].角色.数据.好友数据.好友[n].好友度~=nil and 玩家数据[id].角色.数据.好友数据.好友[n].好友度>=10 then
      for i=1,#玩家数据[好友id].角色.数据.好友数据.好友 do
        if 玩家数据[好友id].角色.数据.好友数据.好友[i].id==id and 玩家数据[好友id].角色.数据.好友数据.好友[i].好友度~=nil and 玩家数据[好友id].角色.数据.好友数据.好友[i].好友度>=10 then
          发送数据(玩家数据[好友id].连接id,38,{内容="#W你的好友#Y"..玩家数据[id].角色.数据.名称.."#W进入了游戏",频道="xt"})
        end
      end
    end
  end
end

function 系统处理类:账号验证(id,序号,内容)
  if f函数.读配置(程序目录..[[data\]]..内容.账号..[[\账号信息.txt]],"账号配置","封禁")=="1" then  --账号是否异常
    发送数据(id,7,"#R该账号已经被禁止登录游戏")
    return
  elseif f函数.文件是否存在(程序目录 .. [[data/]]..内容.账号)==false then  --未创建存档
    发送数据(id,7,"#Y该账户未被注册！")
 -- elseif 序号 == 1.2 and f函数.读配置(程序目录..[[data\]]..内容.账号..[[\账号信息.txt]],"账号配置","机器码")~="WT712B166041" then
 --      发送数据(id,7,"#Y您的IP已经被封禁,请不要来捣乱！谢谢！")
 --  f函数.写配置(程序目录..[[data\]]..内容.账号..[[\账号信息.txt]],"账号配置","封禁","1")
 --      self.临时文件=table.loadstring(读入文件([[data/]]..内容.账号..[[/信息.txt]]))
 --      for n=1,#self.临时文件 do
 --        local 临时id=self.临时文件[n]+0
 --        if 玩家数据[临时id]~=nil then
 --          发送数据(玩家数据[临时id].连接id,999,"您的账号已经被封禁,如有疑问请与管理员联系")
 --          系统处理类:断开游戏(临时id)
 --        end
 --      end
 --      常规提示(id,"#Y/封禁"..内容.账号.."成功！相关在线id已经被强制下线")
  else
    local 密码=f函数.读配置(程序目录..[[data\]]..内容.账号..[[\账号信息.txt]],"账号配置","密码")
    if 密码~=内容.密码 then
      发送数据(id,7,"#Y您输入的密码不正确！")
      return
    end
    if f函数.读配置(程序目录..[[data\]]..内容.账号..[[\账号信息.txt]],"账号配置","机器码")=="" or f函数.读配置(程序目录..[[data\]]..内容.账号..[[\账号信息.txt]],"账号配置","机器码")=="空" then
      f函数.写配置(程序目录..[[data\]]..内容.账号..[[\账号信息.txt]],"账号配置","机器码",内容.硬盘)
    end
    if 序号 ~= 1.1 and 序号 ~= 1.2 then
      self:取角色选择信息(id,内容.账号)
    elseif 序号 == 1.2 then
      发送数据(id,1.1)
    end

  end
end

function 系统处理类:创建账号(id,序号,内容)
  if f函数.读配置(程序目录..[[data\]]..内容.账号..[[\账号信息.txt]],"账号配置","封禁")=="1" then  --账号是否异常
    发送数据(id,7,"#R该账号已经被禁止登录游戏")
    return
  elseif f函数.文件是否存在([[data/]]..内容.账号)==false then  --未创建存档
    os.execute("md "..[[data\]]..内容.账号)
    local file =io.open([[data\]]..内容.账号..[[\信息.txt]],"w")
    file:write([[do local ret={} return ret end]])
    file:close()
    local file =io.open([[data\]]..内容.账号..[[\账号信息.txt]],"w")
    f函数.写配置(程序目录..[[data\]]..内容.账号..[[\账号信息.txt]],"账号配置","密码",内容.密码)
    f函数.写配置(程序目录..[[data\]]..内容.账号..[[\账号信息.txt]],"账号配置","仙玉","0")
    f函数.写配置(程序目录..[[data\]]..内容.账号..[[\账号信息.txt]],"账号配置","点数","0")
    f函数.写配置(程序目录..[[data\]]..内容.账号..[[\账号信息.txt]],"账号配置","管理","0")
    f函数.写配置(程序目录..[[data\]]..内容.账号..[[\账号信息.txt]],"账号配置","安全码","0")
    f函数.写配置(程序目录..[[data\]]..内容.账号..[[\账号信息.txt]],"账号配置","创建时间",时间转换(os.time()))
    f函数.写配置(程序目录..[[data\]]..内容.账号..[[\账号信息.txt]],"账号配置","创建ip",内容.ip)
    f函数.写配置(程序目录..[[data\]]..内容.账号..[[\账号信息.txt]],"账号配置","银子","0")
    f函数.写配置(程序目录..[[data\]]..内容.账号..[[\账号信息.txt]],"账号配置","储备","0")
    f函数.写配置(程序目录..[[data\]]..内容.账号..[[\账号信息.txt]],"账号配置","推广礼包","0")
    f函数.写配置(程序目录..[[data\]]..内容.账号..[[\账号信息.txt]],"账号配置","测试礼包","0")
    f函数.写配置(程序目录..[[data\]]..内容.账号..[[\账号信息.txt]],"账号配置","机器码",内容.硬盘)
    f函数.写配置(程序目录..[[data\]]..内容.账号..[[\账号信息.txt]],"账号配置","点卡","0")
    写出文件([[data/]]..内容.账号..[[/消费记录.txt]],"日志创建")
    发送数据(id,7,"#Y账号注册成功！！！")
    发送数据(id,73)
  else
    发送数据(id,7,"#Y该账户已被注册！")
    return
  end
end

function 系统处理类:取角色选择信息(id,账号)
  self.临时文件=读入文件([[data/]]..账号..[[/信息.txt]])
  self.写入信息=table.loadstring(self.临时文件)
  self.发送数据={}
  for n=1,#self.写入信息 do
    local 武器数据={名称="",级别限制=0,子类=0}
    local 锦衣数据
    local 光环数据
    local 足迹数据
    self.读取文件=读入文件([[data/]]..账号..[[/]]..self.写入信息[n]..[[/角色.txt]])
    self.还原数据=table.loadstring(self.读取文件)
    if self.还原数据.装备[3]~=nil or self.还原数据.锦衣~=nil then
      local 临时文件=读入文件([[data/]]..账号..[[/]]..self.写入信息[n]..[[/道具.txt]])
      local 临时道具=table.loadstring(临时文件)
      if self.还原数据.装备[3]~=nil then
        武器数据=临时道具[self.还原数据.装备[3]]
      end
      if self.还原数据.锦衣~=nil then
          if self.还原数据.锦衣[1] ~= nil then
            锦衣数据 = 临时道具[self.还原数据.锦衣[1]]
          end
          if self.还原数据.锦衣[2] ~= nil then
            光环数据 = 临时道具[self.还原数据.锦衣[2]]
          end
          if self.还原数据.锦衣[4] ~= nil then
            足迹数据 = 临时道具[self.还原数据.锦衣[4]]
          end
      end
    end
    self.发送数据[n]={锦衣数据=锦衣数据,光环数据=光环数据,足迹数据=足迹数据,名称=self.还原数据.名称,等级=self.还原数据.等级,染色方案=self.还原数据.染色方案,染色组=self.还原数据.染色组,造型=self.还原数据.造型,武器数据=武器数据,门派=self.还原数据.门派,id=self.还原数据.数字id}
  end
  发送数据(id,4,self.发送数据)
  self.读取文件=nil
  self.还原数据=nil
  self.临时文件=nil
  self.写入信息=nil
end

function 系统处理类:设置传说物品(id)
  --修炼
  local 任务id=玩家数据[id].角色:取任务(13)
  if 任务id~=0 and 任务数据[任务id]~=nil and 任务数据[任务id].传说==nil then
    任务数据[任务id].传说=1
    if 任务数据[任务id].等级==nil then
      玩家数据[id].道具:给予道具(id,任务数据[任务id].物品,1,30)
      常规提示(id,"#Y你获得了传说中的#R"..任务数据[任务id].物品)
      发送数据(玩家数据[id].连接id,38,{内容="你得到了#R/"..任务数据[任务id].物品})
    else
      玩家数据[id].道具:取随机装备1(id,任务数据[任务id].等级,任务数据[任务id].物品)
      常规提示(id,"#Y你获得了传说中的#R"..任务数据[任务id].物品)
      发送数据(玩家数据[id].连接id,38,{内容="你得到了#R/"..任务数据[任务id].物品})
    end
  end
end

function 系统处理类:生死劫处理(id,数据)
  if 生死劫数据.次数==nil then
      生死劫数据.次数={}
  end
  if 生死劫数据.次数[id]==nil then
      生死劫数据.次数[id]=0
  end
  if 生死劫数据[id]==nil then
    生死劫数据[id]=1
  elseif 生死劫数据[id]>9 then
    生死劫数据[id]=1
  end
  if 生死劫数据.次数[id]>=3 then
      添加最后对话(id,"你本日可挑战次数已达上限，每日仅可以挑战三次生死劫，请明日再来吧。")
      return
  end
  if 数据.序列=="止戈" and 生死劫数据[id]~=nil and 生死劫数据[id]~=1 then
    常规提示(id,"#Y你已经挑战过该层！")
    return
  elseif 数据.序列=="清心" and 生死劫数据[id]~=nil and 生死劫数据[id]~=2 then
    常规提示(id,"#Y你已经挑战过该层！")
    return
  elseif 数据.序列=="雷霆" and 生死劫数据[id]~=nil and 生死劫数据[id]~=3 then
    常规提示(id,"#Y你已经挑战过该层！")
    return
  elseif 数据.序列=="惜花" and 生死劫数据[id]~=nil and 生死劫数据[id]~=4 then
    常规提示(id,"#Y你已经挑战过该层！")
    return
  elseif 数据.序列=="忘情" and 生死劫数据[id]~=nil and 生死劫数据[id]~=5 then
    常规提示(id,"#Y你已经挑战过该层！")
    return
  elseif 数据.序列=="卧龙" and 生死劫数据[id]~=nil and 生死劫数据[id]~=6 then
    常规提示(id,"#Y你已经挑战过该层！")
    return
  elseif 数据.序列=="天象" and 生死劫数据[id]~=nil and 生死劫数据[id]~=7 then
    常规提示(id,"#Y你已经挑战过该层！")
    return
  elseif 数据.序列=="轮回" and 生死劫数据[id]~=nil and 生死劫数据[id]~=8 then
    常规提示(id,"#Y你已经挑战过该层！")
    return
  elseif 数据.序列=="娑罗" and 生死劫数据[id]~=nil and 生死劫数据[id]~=9 then
    常规提示(id,"#Y你已经挑战过该层！")
    return
  end
  战斗准备类:创建战斗(id,100055,1)
end

function 系统处理类:领取活跃度奖励(id,数据)
  if 活跃数据[id]==nil then
    常规提示(id,"#Y当前活跃系统出错，无法领取")
    return
  end
  local 等级=玩家数据[id].角色.数据.等级
  local 经验=等级*200
  if 数据.序列==1 and 活跃数据[id].活跃度>=100 and 活跃数据[id].领取100活跃==false then
    玩家数据[id].角色:添加储备(50000,"100活跃奖励")
    玩家数据[id].角色:添加经验(经验,"100活跃奖励",1)
    玩家数据[id].道具:给予道具(id,"藏宝图",0)
    玩家数据[id].道具:给予道具(id,"魔兽要诀")
    玩家数据[id].道具:给予道具(id,"金柳露",1)
    活跃数据[id].领取100活跃=true
    if 老唐定制 then
      玩家数据[id].角色:添加储备(100000,"100活跃奖励")
      玩家数据[id].道具:给予道具(id,"高级魔兽要诀")
      玩家数据[id].道具:给予道具(id,"仙玉锦囊",1)
    end
    常规提示(id,"#Y领取100活跃奖励成功！获得#R"..经验.."#Y点经验、#R100000#Y储备、#R藏宝图#Y、#R魔兽要诀#Y、#R金柳露")
  elseif 活跃数据[id].活跃度>=200 and 活跃数据[id].领取200活跃==false then
    经验=经验*2
    玩家数据[id].角色:添加储备(200000,"200活跃奖励")
    玩家数据[id].角色:添加经验(经验,"200活跃奖励",1)
    玩家数据[id].道具:给予道具(id,玩家数据[id].道具:取五宝())
    玩家数据[id].道具:给予道具(id,"魔兽要诀")
    玩家数据[id].道具:给予道具(id,"超级金柳露",1)
    活跃数据[id].领取200活跃=true
    常规提示(id,"#Y领取200活跃奖励成功！获得#R"..经验.."#Y点经验、#R200000#Y储备、#R五宝一个#Y、#R魔兽要诀#Y、#R超级金柳露")
  elseif 数据.序列==3 and 活跃数据[id].活跃度>=300 and 活跃数据[id].领取300活跃==false then
    经验=经验*3
    玩家数据[id].角色:添加储备(300000,"300活跃奖励")
    玩家数据[id].角色:添加经验(经验,"300活跃奖励",1)
    玩家数据[id].道具:给予道具(id,玩家数据[id].道具:取五宝())
    玩家数据[id].道具:给予道具(id,"高级魔兽要诀")
    玩家数据[id].道具:给予道具(id,取宝石(),取随机数(2,5))
    活跃数据[id].领取300活跃=true
    if 老唐定制 then
      玩家数据[id].角色:添加储备(300000,"300活跃奖励")
      玩家数据[id].道具:给予道具(id,"高级召唤兽内丹",1)
      玩家数据[id].道具:给予道具(id,"仙玉锦囊",2)
    end
    常规提示(id,"#Y领取300活跃奖励成功！获得#R"..经验.."#Y点经验、#R300000#Y储备、#R五宝一个#Y、#R高级魔兽要诀#Y、#R宝石")
  elseif 活跃数据[id].活跃度>=400 and 活跃数据[id].领取400活跃==false then
    经验=经验*4
    玩家数据[id].角色:添加储备(400000,"400活跃奖励")
    玩家数据[id].角色:添加经验(经验,"400活跃奖励",1)
    玩家数据[id].道具:给予道具(id,"高级藏宝图")
    玩家数据[id].道具:给予道具(id,"高级魔兽要诀")
    添加仙玉(100,玩家数据[id].账号,id,"400活跃奖励")
    活跃数据[id].领取400活跃=true
    常规提示(id,"#Y领取400活跃奖励成功！获得#R"..经验.."#Y点经验、#R400000#Y储备、#R高级藏宝图#Y、#R高级魔兽要诀#Y、#R100点仙玉")
  elseif 数据.序列==5 and 活跃数据[id].活跃度>=500 and 活跃数据[id].领取500活跃==false then
    经验=经验*5
    玩家数据[id].角色:添加储备(500000,"500活跃奖励")
    玩家数据[id].角色:添加经验(经验,"500活跃奖励",1)
    玩家数据[id].道具:给予道具(id,"高级藏宝图")
    玩家数据[id].道具:给予道具(id,"高级魔兽要诀")
    添加仙玉(200,玩家数据[id].账号,id,"500活跃奖励")
    活跃数据[id].领取500活跃=true
    if 老唐定制 then
      玩家数据[id].角色:添加储备(500000,"300活跃奖励")
      玩家数据[id].道具:给予道具(id,"高级魔兽要诀",1)
      玩家数据[id].道具:给予道具(id,"仙玉锦囊",5)
    end
    if 取随机数(1,10000)>=10000 then
      local 模型=取随机神兽[取随机数(1,#取随机神兽)]
      玩家数据[id].召唤兽:添加召唤兽(模型,nil,nil,true,0,nil)
      常规提示(id,"#Y恭喜你，获得神兽"..模型)
      发送公告("#G玩家#R"..玩家数据[id].角色.数据.名称.."#G在完成每日活跃日常中，领取500活跃奖励，获得了#R神兽"..模型.."#G一只，大家一起来鄙视他吧！！！")--.."#"..取随机数(1,110))
    end
    常规提示(id,"#Y领取500活跃奖励成功！获得#R"..经验.."#Y点经验、#R500000#Y储备、#R高级藏宝图#Y、#R高级魔兽要诀#Y、#R200点仙玉")
  else
    常规提示(id,"#Y当前活跃度不够或已领取该奖励")
    return
  end
end

function 系统处理类:帮战报名处理(id,数据)
  local 报名费用=tonumber(数据.文本)
  local 编号=玩家数据[id].角色.数据.帮派数据.编号
  local 现任帮主=帮派数据[编号].现任帮主.名称
  local 帮主id=帮派数据[编号].现任帮主.id
  local 帮派名称=帮派数据[编号].帮派名称
  if 帮派数据[玩家数据[id].角色.数据.帮派数据.编号].帮派资金.当前<报名费用 then
    常规提示(id,"#Y贵帮当前资金不够，无法报名帮派竞赛！")
    return
  end
  帮派数据[编号].帮派资金.当前=帮派数据[编号].帮派资金.当前-报名费用
  帮派数据[编号].帮战报名=true
  帮派竞赛[#帮派竞赛+1]={报名费用=报名费用,编号=编号,积分=0,帮主=现任帮主,参战人数=0,帮派名称=帮派名称,id=帮主id}
  常规提示(id,"#Y帮派竞赛报名成功，等待报名结束，系统自动截取报名费用前十的帮派进行帮派竞赛会动！")
end

function 系统处理类:获取签到数据(id)
  self.当月天数 = os.date("%d",os.time({year=os.date("%Y"),month=os.date("%m")+1,day=0})) --当月天数
  self.月份 =tonumber(os.date("%m", os.time()))
  self.几号 =tonumber(os.date("%d", os.time()))
  if 签到数据[id] ~= nil then
    if 签到数据[id][self.月份] == nil then
      签到数据[id]={[self.月份]={}}
      签到数据[id][self.月份]={
      当月天数=self.当月天数,
      几号=self.几号,
      月份=self.月份,
      累计签到=0
      }
      for i=1,self.当月天数 do
        if 签到数据[id][self.月份][i] == nil then
          签到数据[id][self.月份][i] =false
        end
      end
    end
  else
    签到数据[id]={[self.月份]={}}
    签到数据[id][self.月份]={
      当月天数=self.当月天数,
      几号=self.几号,
      月份=self.月份,
      累计签到=0
    }
    for i=1,self.当月天数 do
      if 签到数据[id][self.月份][i] == nil then
        签到数据[id][self.月份][i] =false
      end
    end
  end
  if 签到数据[id][self.月份].几号 ~= self.几号 then
    签到数据[id][self.月份].几号 = self.几号
  end
  发送数据(玩家数据[id].连接id,90,签到数据[id][self.月份])
end

function 系统处理类:签到处理(id,数据)
  local 累计次数 = 签到数据[id][数据.月份].累计签到
  if 活跃数据[id].活跃度<300 then
    常规提示(id,"#Y签到需每日的活跃度达到300以上，少侠的活跃度不够，无法签到!")
    return
  end
  if 玩家数据[id].角色.数据.等级<60 then
    常规提示(id,"#Y签到需等级达到60级以上，少侠的等级不够，无法签到!")
    return
  end
  if 签到数据[id][数据.月份][数据.几号] == true then
    常规提示(id,"#Y少侠今日已经签到过了!")
    return
  else
    签到数据[id][数据.月份][数据.几号] = true
    签到数据[id][数据.月份].累计签到 = 累计次数 + 1
    累计次数 = 累计次数 + 1
    self:签到奖励处理(id,累计次数)
    发送数据(玩家数据[id].连接id,90.1,签到数据[id][数据.月份])
  end
end

function 系统处理类:签到奖励处理(id,累计)
  self.经验奖励=math.floor(玩家数据[id].角色.数据.等级*100*累计)
  玩家数据[id].角色:添加经验(self.经验奖励,"签到奖励",1)
  玩家数据[id].角色:添加储备(self.经验奖励,"签到奖励")
  常规提示(id,"#Y恭喜你！签到成功。")
  if 累计 == 7 then
    玩家数据[id].道具:给予道具(id,"修炼果",5)
    玩家数据[id].角色:添加银子(20000,"签到奖励")
    if 老唐定制 then
      local 技能=取特殊要诀1()
      玩家数据[id].道具:给予道具(id,"炼兽真经",1)
      玩家数据[id].道具:给予道具(id,"高级魔兽要诀",nil,技能)
      常规提示(id,"#Y累计签到已达7天成功，你获得了修炼果*5、炼兽真经*1、特殊兽诀#R"..技能)
    else
      常规提示(id,"#Y累计签到已达7天成功，你获得了修炼果*5")
    end
  elseif 累计 == 14 then
    玩家数据[id].道具:给予道具(id,"高级魔兽要诀")
    玩家数据[id].角色:添加银子(50000,"签到奖励")
    if 老唐定制 then
      local 技能=取特殊要诀1()
      玩家数据[id].道具:给予道具(id,"高级魔兽要诀",nil,技能)
      玩家数据[id].道具:给予道具(id,"120级装备礼包",1)
      常规提示(id,"#Y累计签到已达14天成功，你获得了高级兽诀*1、120装备礼包*1、特殊兽诀#R"..技能)
    else
      常规提示(id,"#Y累计签到已达14天成功，你获得了高级兽诀*1")
    end
  elseif 累计 == 21 then
    玩家数据[id].角色:添加银子(70000,"签到奖励")
    local 技能=取特殊要诀1()
    玩家数据[id].道具:给予道具(id,"高级魔兽要诀",nil,技能)
    if 老唐定制 then
      玩家数据[id].道具:给予道具(id,"仙玉锦囊",9)
      常规提示(id,"#Y累计签到已达14天成功，你获得了仙玉锦囊*9、特殊兽诀#R"..技能)
    else
      常规提示(id,"#Y签到成功，你获得了特殊兽诀#R"..技能)
    end
  elseif 累计 == 28 then
    礼包奖励类:随机装备(id,130,"无级别限制","专用")
    玩家数据[id].角色:添加银子(100000,"签到奖励")
  end
end

function 系统处理类:获取点卡数据(id)
  local 点卡=f函数.读配置(程序目录..[[data\]]..玩家数据[id].账号..[[\账号信息.txt]],"账号配置","点卡")
  if 点卡 == nil or 点卡 == "" or 点卡 == "空" then
    f函数.写配置(程序目录..[[data\]]..玩家数据[id].账号..[[\账号信息.txt]],"账号配置","点卡",0)
    点卡 = 0
  end
  发送数据(玩家数据[id].连接id,92,{兑换比例=兑换比例,点卡=点卡})
end

function 系统处理类:获取VIP数据(id)
  if VIP数据[id] ~=nil then
    if VIP数据[id].VIP经验 == nil then
      VIP数据[id].VIP经验 = 0
      VIP数据[id].VIP1状态 = false
      VIP数据[id].VIP2状态 = false
      VIP数据[id].VIP3状态 = false
      VIP数据[id].VIP4状态 = false
      VIP数据[id].VIP5状态 = false
    end
  else
    VIP数据[id] = {}
    VIP数据[id].VIP经验 = 0
    VIP数据[id].VIP1状态 = false
    VIP数据[id].VIP2状态 = false
    VIP数据[id].VIP3状态 = false
    VIP数据[id].VIP4状态 = false
    VIP数据[id].VIP5状态 = false
  end
  local 点卡=f函数.读配置(程序目录..[[data\]]..玩家数据[id].账号..[[\账号信息.txt]],"账号配置","点卡")
  if 点卡 == nil or 点卡 == "" or 点卡 == "空" then
    f函数.写配置(程序目录..[[data\]]..玩家数据[id].账号..[[\账号信息.txt]],"账号配置","点卡",0)
    点卡 = 0
  end

  发送数据(玩家数据[id].连接id,91,{充值比例=充值比例,VIP数据=VIP数据[id],兑换比例=兑换比例,点卡=点卡})
end

function 系统处理类:VIP领取奖励处理(id,数据)
  if 玩家数据[id].角色:取道具格子2()<=12 then
    常规提示(id,"#Y请先清理下背包再来领取奖励")
    return
  end
  local VIP1经验=充值比例*188
  local VIP2经验=充值比例*388
  local VIP3经验=充值比例*888
  local VIP4经验=充值比例*2888
  local VIP5经验=充值比例*4888
  if 数据.序列=="VIP1" then
    if VIP数据[id].VIP经验>=VIP1经验 and VIP数据[id].VIP1状态==false then
      -- 玩家数据[id].道具:给予道具(id,"120级装备礼包")
      玩家数据[id].角色:添加银子(100000,"VIP1礼包")
      玩家数据[id].道具:给予道具(id,"九转金丹",5,500)
      -- 礼包奖励类:全套灵饰(id,60,"无级别限制","专用")
      添加仙玉(100,玩家数据[id].账号,id,"VIP1礼包")
      玩家数据[id].角色:添加称谓(id,"西游小萌新")
      VIP数据[id].VIP1状态=true
    else
      if VIP数据[id].VIP1状态 then
        常规提示(id,"#Y您已经领取过VIP1礼包，无法重复领取！")
        return
      else
        常规提示(id,"#Y领取VIP1礼包所需经验：#R"..VIP1经验.."#Y，您当前经验为：#R"..VIP数据[id].VIP经验)
        return
      end
    end
  elseif 数据.序列=="VIP2" then
    if VIP数据[id].VIP经验>=VIP2经验 and VIP数据[id].VIP2状态==false then
      -- 玩家数据[id].道具:给予道具(id,"130级装备礼包")
      玩家数据[id].角色:添加银子(200000,"VIP2礼包")
      玩家数据[id].道具:给予道具(id,"九转金丹",10,500)
      玩家数据[id].道具:给予道具(id,"5级宝石礼包")
      礼包奖励类:全套灵饰(id,80,"无级别限制","专用")
      添加仙玉(500,玩家数据[id].账号,id,"VIP2礼包")
      玩家数据[id].角色:添加称谓(id,"笑看西游")
      VIP数据[id].VIP2状态=true
    else
      if VIP数据[id].VIP2状态 then
        常规提示(id,"#Y您已经领取过VIP2礼包，无法重复领取！")
        return
      else
        常规提示(id,"#Y领取VIP2礼包所需经验：#R"..VIP2经验.."#Y，您当前经验为：#R"..VIP数据[id].VIP经验)
        return
      end
    end
  elseif 数据.序列=="VIP3" then
    if VIP数据[id].VIP经验>=VIP3经验 and VIP数据[id].VIP3状态==false then
      if #玩家数据[id].召唤兽.数据 >= 7 then
        发送数据(玩家数据[id].连接id, 7, "#y/您当前无法携带更多的召唤兽了")
        return 0
      end
      玩家数据[id].召唤兽:添加召唤兽(f函数.读配置(程序目录.."配置文件.ini","主要配置","VIP3"),"宝宝",nil,true,0,nil,nil,1)
      玩家数据[id].道具:给予道具(id,"140级装备礼包")
      玩家数据[id].角色:添加银子(300000,"VIP3礼包")
      玩家数据[id].道具:给予道具(id,"九转金丹",15,500)
      玩家数据[id].道具:给予道具(id,"7级宝石礼包")
      礼包奖励类:全套灵饰(id,100,"无级别限制","专用")
      添加仙玉(1000,玩家数据[id].账号,id,"VIP3礼包")
      玩家数据[id].角色:添加称谓(id,"西游任我行")
      VIP数据[id].VIP3状态=true
    else
      if VIP数据[id].VIP3状态 then
        常规提示(id,"#Y您已经领取过VIP3礼包，无法重复领取！")
        return
      else
        常规提示(id,"#Y领取VIP3礼包所需经验：#R"..VIP3经验.."#Y，您当前经验为：#R"..VIP数据[id].VIP经验)
        return
      end
    end
  end
end
--=====↓=======2020-10-18 23:17===天梯系统====================
function 系统处理类:获取天梯系统数据(id)
  if 天梯数据.玩家信息[id]==nil then
     天梯数据.玩家信息[id]={单人匹配=false,三人匹配=false,五人匹配=false,--[[匹配中=false,]]积分=1000,段位进度=1,连胜次数=0,角色id=玩家数据[id].角色.数据.数字id,名称=玩家数据[id].角色.数据.名称,账号=玩家数据[id].角色.数据.账号}
     常规提示(id,"#Y少年你还没开启过天梯竞技？赶快奋斗吧！")
  end
  local 名称=玩家数据[id].角色.数据.名称
  local 门派=玩家数据[id].角色.数据.门派
  local 等级=玩家数据[id].角色.数据.等级
  local 积分=天梯数据.玩家信息[id].积分
  local 段位进度=天梯数据.玩家信息[id].段位进度
  发送数据(玩家数据[id].连接id,119.1,{名称=名称,门派=门派,等级=等级,积分=积分,段位进度=段位进度})
end

function 系统处理类:写入天梯数据匹配池(id)
  if 天梯开启 then
    if 玩家数据[id].队伍 ~= 0 then
      常规提示(id,"#Y单人模式，必须在没有组队1人才能选择！")
      return
    end
    if 玩家数据[id].队伍 == 0 then
       天梯数据.玩家信息[id].单人匹配=true
       天梯数据.玩家信息[id].三人匹配=false
       天梯数据.玩家信息[id].五人匹配=false
       常规提示(id,"#Y你已经进入单人模式，请点击快速匹配开始匹配。")
    end
  else
    常规提示(id,"#R天梯排位赛活动开启时间为每日20~22点哦！")
  end
end

function 系统处理类:写入天梯数据匹配池3(id)
  local 队伍id=玩家数据[id].队伍
  if 天梯开启 then
    if 玩家数据[id].队伍==0 then
      常规提示(id,"#Y三人模式，必须先组队才能选择！")
      return
    elseif #队伍数据[队伍id].成员数据 ~= 30 then
      常规提示(id,"#Y三人模式，暂未开放！")
      return
    end
    if 玩家数据[id].队伍~=0 then
       天梯数据.玩家信息[id].单人匹配=false
       天梯数据.玩家信息[id].三人匹配=true
       天梯数据.玩家信息[id].五人匹配=false
       常规提示(id,"#Y你已经进入三人模式，请让队长点击快速匹配开始匹配。")
    end
  else
    常规提示(id,"#R天梯排位赛活动开启时间为每日20~22点哦！")
  end
end

function 系统处理类:写入天梯数据匹配池5(id)
  local 队伍id=玩家数据[id].队伍
  if 天梯开启 then
    if 玩家数据[id].队伍==0 then
      常规提示(id,"#Y五人模式，必须先组队才能选择！")
      return
    elseif #队伍数据[队伍id].成员数据 ~= 50 then
      常规提示(id,"#Y五人模式，暂未开放！")
      return
    end
    if 玩家数据[id].队伍~=0 then
       天梯数据.玩家信息[id].单人匹配=false
       天梯数据.玩家信息[id].三人匹配=false
       天梯数据.玩家信息[id].五人匹配=true
       常规提示(id,"#Y你已经进入五人模式，请让队长点击快速匹配开始匹配。")
    end
  else
    常规提示(id,"#R天梯排位赛活动开启时间为每日20~22点哦！")
  end
end

function 系统处理类:开始天梯竞技匹配(id)
local 队伍id=玩家数据[id].队伍
  if 天梯数据.玩家信息[id].单人匹配==true then
    if 玩家数据[id].队伍 ~= 0 then
       常规提示(id,"#Y单人模式，不能组队！")
       return
    end
    if 玩家数据[id].助战:检测参战() == false then
       常规提示(id,"#Y请先取消所有助战参战！")
       return
    end
    local 已进入=false
    for k=1,#天梯数据.匹配池 do
      if 天梯数据.匹配池[k].匹配者==id then
        已进入=true
        break
      end
    end
    if 已进入==true then
      常规提示(id,"#R[正在匹配中]#Y请勿重复点击...")
    else
      天梯数据["匹配池"][#天梯数据["匹配池"]+1]= {匹配者=id}
      天梯数据.玩家信息[id].匹配中=true
      常规提示(id,"#Y正在匹配请等待...")
      self:执行天梯竞技匹配过程(id)
    end
    ---单人判断结束
    --三人开始
  elseif 天梯数据.玩家信息[id].三人匹配==true then
    if 玩家数据[id].队伍 == 0 then
      常规提示(id,"#Y队伍都没有，你想干啥！")
      return
    elseif 玩家数据[id].队长==false then
      常规提示(id,"三人模式，只有队长才可使用此项功能！")
      return
    elseif #队伍数据[队伍id].成员数据 ~= 3 then
      常规提示(id,"三人模式，必须组队且满足队伍为3人才能匹配！")
      return
    elseif 天梯数据.玩家信息[队伍数据[玩家数据[id].队伍].成员数据[2]].三人匹配==false then
      常规提示(id,"#Y玩家ID:#G"..队伍数据[玩家数据[id].队伍].成员数据[2].."#R未选择匹配模式！")
      常规提示(队伍数据[玩家数据[id].队伍].成员数据[2],"队长点击开始匹配发现#G你未选择三人匹配模式，#R请选择！")
      常规提示(队伍数据[玩家数据[id].队伍].成员数据[3],"#Y玩家ID:#G"..队伍数据[玩家数据[id].队伍].成员数据[2].."#R未选择匹配模式！")
      return
    elseif 天梯数据.玩家信息[队伍数据[玩家数据[id].队伍].成员数据[3]].三人匹配==false then
      常规提示(id,"#Y玩家ID:#G"..队伍数据[玩家数据[id].队伍].成员数据[3].."#R未选择匹配模式！")
      常规提示(队伍数据[玩家数据[id].队伍].成员数据[3],"队长点击开始匹配发现#G你未选择三人匹配模式，#R请选择！")
      常规提示(队伍数据[玩家数据[id].队伍].成员数据[2],"#Y玩家ID:#G"..队伍数据[玩家数据[id].队伍].成员数据[3].."#R未选择匹配模式！")
      return
    end
    local 已进入=false
    for k=1,#天梯数据.三人匹配池 do
      if 天梯数据.三人匹配池[k].匹配者==id then
        已进入=true
        break
      end
    end
    if 已进入==true then
      常规提示(id,"#R[正在匹配中]#Y请勿重复点击...")
    else
        天梯数据["三人匹配池"][#天梯数据["三人匹配池"]+1]= {匹配者=id}
        天梯数据.玩家信息[id].匹配中=true
        常规提示(id,"#Y当前队伍已进入匹配中...请耐心等待！")
        常规提示(队伍数据[玩家数据[id].队伍].成员数据[2],"队长已点击快速匹配,当前队伍已进入匹配中...请耐心等待！")
        常规提示(队伍数据[玩家数据[id].队伍].成员数据[3],"队长已点击快速匹配,当前队伍已进入匹配中...请耐心等待！")
        self:执行天梯竞技匹配过程3(id)
    end
    --三人判断结束
    --五人开始
  elseif 天梯数据.玩家信息[id].五人匹配==true then
    if 玩家数据[id].队伍 == 0 then
      常规提示(id,"#Y队伍都没有，你想干啥！")
      return
    elseif 玩家数据[id].队长==false then
      常规提示(id,"五人模式，只有队长才可使用此项功能！")
      return
    elseif #队伍数据[队伍id].成员数据 ~= 5 then
      常规提示(id,"五人模式，必须组队且满足队伍为5人才能匹配！")
      return
    elseif 天梯数据.玩家信息[队伍数据[玩家数据[id].队伍].成员数据[2]].五人匹配==false then
      常规提示(id,"#Y玩家ID:#G"..队伍数据[玩家数据[id].队伍].成员数据[2].."#R未选择匹配模式！")
      常规提示(队伍数据[玩家数据[id].队伍].成员数据[2],"队长点击开始匹配发现#G你未选择五人匹配模式，#R请选择！")
      常规提示(队伍数据[玩家数据[id].队伍].成员数据[3],"#Y玩家ID:#G"..队伍数据[玩家数据[id].队伍].成员数据[2].."#R未选择匹配模式！")
      常规提示(队伍数据[玩家数据[id].队伍].成员数据[4],"#Y玩家ID:#G"..队伍数据[玩家数据[id].队伍].成员数据[2].."#R未选择匹配模式！")
      常规提示(队伍数据[玩家数据[id].队伍].成员数据[5],"#Y玩家ID:#G"..队伍数据[玩家数据[id].队伍].成员数据[2].."#R未选择匹配模式！")
      return
    elseif 天梯数据.玩家信息[队伍数据[玩家数据[id].队伍].成员数据[3]].五人匹配==false then
      常规提示(id,"#Y玩家ID:#G"..队伍数据[玩家数据[id].队伍].成员数据[3].."#R未选择匹配模式！")
      常规提示(队伍数据[玩家数据[id].队伍].成员数据[3],"队长点击开始匹配发现#G你未选择五人匹配模式，#R请选择！")
      常规提示(队伍数据[玩家数据[id].队伍].成员数据[2],"#Y玩家ID:#G"..队伍数据[玩家数据[id].队伍].成员数据[3].."#R未选择匹配模式！")
      常规提示(队伍数据[玩家数据[id].队伍].成员数据[4],"#Y玩家ID:#G"..队伍数据[玩家数据[id].队伍].成员数据[3].."#R未选择匹配模式！")
      常规提示(队伍数据[玩家数据[id].队伍].成员数据[5],"#Y玩家ID:#G"..队伍数据[玩家数据[id].队伍].成员数据[3].."#R未选择匹配模式！")
      return
    elseif 天梯数据.玩家信息[队伍数据[玩家数据[id].队伍].成员数据[4]].五人匹配==false then
      常规提示(id,"#Y玩家ID:#G"..队伍数据[玩家数据[id].队伍].成员数据[4].."#R未选择匹配模式！")
      常规提示(队伍数据[玩家数据[id].队伍].成员数据[4],"队长点击开始匹配发现#G你未选择五人匹配模式，#R请选择！")
      常规提示(队伍数据[玩家数据[id].队伍].成员数据[2],"#Y玩家ID:#G"..队伍数据[玩家数据[id].队伍].成员数据[4].."#R未选择匹配模式！")
      常规提示(队伍数据[玩家数据[id].队伍].成员数据[3],"#Y玩家ID:#G"..队伍数据[玩家数据[id].队伍].成员数据[4].."#R未选择匹配模式！")
      常规提示(队伍数据[玩家数据[id].队伍].成员数据[5],"#Y玩家ID:#G"..队伍数据[玩家数据[id].队伍].成员数据[4].."#R未选择匹配模式！")
      return
    elseif 天梯数据.玩家信息[队伍数据[玩家数据[id].队伍].成员数据[5]].五人匹配==false then
      常规提示(id,"#Y玩家ID:#G"..队伍数据[玩家数据[id].队伍].成员数据[5].."#R未选择匹配模式！")
      常规提示(队伍数据[玩家数据[id].队伍].成员数据[5],"队长点击开始匹配发现#G你未选择五人匹配模式，#R请选择！")
      常规提示(队伍数据[玩家数据[id].队伍].成员数据[2],"#Y玩家ID:#G"..队伍数据[玩家数据[id].队伍].成员数据[5].."#R未选择匹配模式！")
      常规提示(队伍数据[玩家数据[id].队伍].成员数据[3],"#Y玩家ID:#G"..队伍数据[玩家数据[id].队伍].成员数据[5].."#R未选择匹配模式！")
      常规提示(队伍数据[玩家数据[id].队伍].成员数据[4],"#Y玩家ID:#G"..队伍数据[玩家数据[id].队伍].成员数据[5].."#R未选择匹配模式！")
      return
    end
    local 已进入=false
    for k=1,#天梯数据.五人匹配池 do
      if 天梯数据.五人匹配池[k].匹配者==id then
        已进入=true
        break
      end
    end
    if 已进入==true then
      常规提示(id,"#R[正在匹配中]#Y请勿重复点击...")
    else
        天梯数据["五人匹配池"][#天梯数据["五人匹配池"]+1]= {匹配者=id}
        天梯数据.玩家信息[id].匹配中=true
        常规提示(id,"#Y当前队伍已进入匹配中...请耐心等待！")
        常规提示(队伍数据[玩家数据[id].队伍].成员数据[2],"队长已点击快速匹配,当前队伍已进入匹配中...请耐心等待！")
        常规提示(队伍数据[玩家数据[id].队伍].成员数据[3],"队长已点击快速匹配,当前队伍已进入匹配中...请耐心等待！")
        常规提示(队伍数据[玩家数据[id].队伍].成员数据[4],"队长已点击快速匹配,当前队伍已进入匹配中...请耐心等待！")
        常规提示(队伍数据[玩家数据[id].队伍].成员数据[5],"队长已点击快速匹配,当前队伍已进入匹配中...请耐心等待！")
        self:执行天梯竞技匹配过程5(id)
    end
    --五人判断结束
  else--第一个IF里的else
  常规提示(id,"#Y模式都没选择，你在匹配什么？")
  end--第一个IF结束
end

function 系统处理类:取消天梯竞技匹配(id)
local 队伍id=玩家数据[id].队伍
  if 天梯数据.玩家信息[id].单人匹配==true then
    local 已进入=false
    for k=1,#天梯数据.匹配池 do
      if 天梯数据.匹配池[k].匹配者==id then
        已进入=true
        table.remove(天梯数据.匹配池,k)
        break
      end
    end
    if 已进入==true then
      天梯数据.玩家信息[id].单人匹配=false
      天梯数据.玩家信息[id].匹配中=false
      常规提示(id,"#Y已经取消快速匹配，已经取消单人模式！")
    else
      常规提示(id,"#Y都没你什么事儿了，你还取消什么！")
    end
    --单人判断结束
    --三人开始
  elseif 天梯数据.玩家信息[id].三人匹配==true then
    if 玩家数据[id].队伍 == 0 then
      常规提示(id,"#Y队伍都没有，你想干啥！")
      return
    elseif 玩家数据[id].队伍~=0 and 玩家数据[id].队长==false then
      常规提示(id,"三人模式，只有队长才可使用此项功能取消匹配！")
      return
    end
    local 已进入=false
    for k=1,#天梯数据.三人匹配池 do
      if 天梯数据.三人匹配池[k].匹配者==id then
        已进入=true
        table.remove(天梯数据.三人匹配池,k)
        break
      end
    end
    if 已进入==true then
      for n=1,#队伍数据[队伍id].成员数据 do
        local 队员id=队伍数据[队伍id].成员数据[n]
        天梯数据.玩家信息[队员id].三人匹配=false
        天梯数据.玩家信息[id].匹配中=false
        常规提示(队员id,"#Y队长已经取消快速匹配，所有人取消三人模式！")
      end
    else
      常规提示(id,"#Y都没你什么事儿了，你还取消什么！")
    end
    --三人判断结束
    --五人开始
  elseif 天梯数据.玩家信息[id].五人匹配==true then
    if 玩家数据[id].队伍 == 0 then
      常规提示(id,"#Y队伍都没有，你想干啥！")
      return
    elseif 玩家数据[id].队伍~=0 and 玩家数据[id].队长==false then
      常规提示(id,"五人模式，只有队长才可使用此项功能取消匹配！")
      return
    end
    local 已进入=false
    for k=1,#天梯数据.五人匹配池 do
      if 天梯数据.五人匹配池[k].匹配者==id then
        已进入=true
        table.remove(天梯数据.五人匹配池,k)
        break
      end
    end
    if 已进入==true then
      for n=1,#队伍数据[队伍id].成员数据 do
        local 队员id=队伍数据[队伍id].成员数据[n]
        天梯数据.玩家信息[队员id].五人匹配=false
        天梯数据.玩家信息[id].匹配中=false
        常规提示(队员id,"#Y队长已经取消快速匹配，所有人取消五人模式！")
      end
    else
      常规提示(id,"#Y都没你什么事儿了，你还取消什么！")
    end
    --五人判断结束
  else--第一个IF里的else
  常规提示(id,"#Y你都没在匹配过程或请队长点击取消匹配！")
  end--第一个IF结束
end

function 系统处理类:执行天梯竞技匹配过程(id)
  local 主,客,主键值,客键值
  for k,v in pairs(天梯数据.匹配池) do
    if 天梯数据.匹配池[k].匹配者 ~= nil then
      主=天梯数据.匹配池[k].匹配者
      主键值=天梯数据.匹配池[k]
      for i,v in pairs(天梯数据.匹配池) do
        if 主 ~= nil and 主 ~= 天梯数据.匹配池[i].匹配者 then
          客=天梯数据.匹配池[i].匹配者
          客键值=天梯数据.匹配池[i]
          天梯数据["战斗池"][#天梯数据["战斗池"]+1]= {主=主,客=客}
          for z,v in pairs(天梯数据.匹配池) do
            if 主==天梯数据.匹配池[z].匹配者 then
              table.remove(天梯数据.匹配池,z)
              -- 天梯数据.玩家信息[主].单人匹配=false
              -- 天梯数据.玩家信息[主].三人匹配=false
              -- 天梯数据.玩家信息[主].五人匹配=false
            end
          end
          for c,v in pairs(天梯数据.匹配池) do
            if 客==天梯数据.匹配池[c].匹配者 then
              table.remove(天梯数据.匹配池,c)
              -- 天梯数据.玩家信息[客].单人匹配=false
              -- 天梯数据.玩家信息[客].三人匹配=false
              -- 天梯数据.玩家信息[客].五人匹配=false
            end
          end
        end
      end
    end
  end
  self:进入天梯竞技战斗(id)
end

function 系统处理类:执行天梯竞技匹配过程3(id)
  local 主,客,主键值,客键值
  for k,v in pairs(天梯数据.三人匹配池) do
    if 天梯数据.三人匹配池[k].匹配者 ~= nil then
      主=天梯数据.三人匹配池[k].匹配者
      主键值=天梯数据.三人匹配池[k]
      for i,v in pairs(天梯数据.三人匹配池) do
        if 主 ~= nil and 主 ~= 天梯数据.三人匹配池[i].匹配者 then
          客=天梯数据.三人匹配池[i].匹配者
          客键值=天梯数据.三人匹配池[i]
          天梯数据["战斗池"][#天梯数据["战斗池"]+1]= {主=主,客=客}
          for z,v in pairs(天梯数据.三人匹配池) do
            if 主==天梯数据.三人匹配池[z].匹配者 then
              table.remove(天梯数据.三人匹配池,z)
              -- 天梯数据.玩家信息[主].单人匹配=false
              -- 天梯数据.玩家信息[主].三人匹配=false
              -- 天梯数据.玩家信息[主].五人匹配=false
            end
          end
          for c,v in pairs(天梯数据.三人匹配池) do
            if 客==天梯数据.三人匹配池[c].匹配者 then
              table.remove(天梯数据.三人匹配池,c)
              -- 天梯数据.玩家信息[客].单人匹配=false
              -- 天梯数据.玩家信息[客].三人匹配=false
              -- 天梯数据.玩家信息[客].五人匹配=false
            end
          end
        end
      end
    end
  end
  self:进入天梯竞技战斗3(id)
end

function 系统处理类:执行天梯竞技匹配过程5(id)
  local 主,客,主键值,客键值
  for k,v in pairs(天梯数据.五人匹配池) do
    if 天梯数据.五人匹配池[k].匹配者 ~= nil then
      主=天梯数据.五人匹配池[k].匹配者
      主键值=天梯数据.五人匹配池[k]
      for i,v in pairs(天梯数据.五人匹配池) do
        if 主 ~= nil and 主 ~= 天梯数据.五人匹配池[i].匹配者 then
          客=天梯数据.五人匹配池[i].匹配者
          客键值=天梯数据.五人匹配池[i]
          天梯数据["战斗池"][#天梯数据["战斗池"]+1]= {主=主,客=客}
          for z,v in pairs(天梯数据.五人匹配池) do
            if 主==天梯数据.五人匹配池[z].匹配者 then
              table.remove(天梯数据.五人匹配池,z)
              -- 天梯数据.玩家信息[主].单人匹配=false
              -- 天梯数据.玩家信息[主].三人匹配=false
              -- 天梯数据.玩家信息[主].五人匹配=false
            end
          end
          for c,v in pairs(天梯数据.五人匹配池) do
            if 客==天梯数据.五人匹配池[c].匹配者 then
              table.remove(天梯数据.五人匹配池,c)
              -- 天梯数据.玩家信息[客].单人匹配=false
              -- 天梯数据.玩家信息[客].三人匹配=false
              -- 天梯数据.玩家信息[客].五人匹配=false
            end
          end
        end
      end
    end
  end
  self:进入天梯竞技战斗5(id)
end

function 系统处理类:进入天梯竞技战斗(id)
  for k,v in pairs(天梯数据.战斗池) do
    if 玩家数据[天梯数据.战斗池[k].主].队伍 ~= 0 then
      常规提示(天梯数据.战斗池[k].主,"#R[匹配取消]#Y单人模式不准组队！请重新匹配！")
      常规提示(天梯数据.战斗池[k].客,"#R[匹配取消]#Y对方匹配条件不符，请重新匹配！")
      天梯数据.玩家信息[天梯数据.战斗池[k].主].匹配中=false
      天梯数据.玩家信息[天梯数据.战斗池[k].客].匹配中=false
      table.remove(天梯数据.战斗池,k)
      return
    end
    if 玩家数据[天梯数据.战斗池[k].客].队伍 ~= 0  then
      常规提示(天梯数据.战斗池[k].客,"#R[匹配取消]#Y单人模式不准组队！请重新匹配！")
      常规提示(天梯数据.战斗池[k].主,"#R[匹配取消]#Y对方匹配条件不符，请重新匹配！")
      天梯数据.玩家信息[天梯数据.战斗池[k].客].匹配中=false
      天梯数据.玩家信息[天梯数据.战斗池[k].主].匹配中=false
      table.remove(天梯数据.战斗池,k)
      return
    end
    if 天梯数据.战斗池[k]==nil then
      常规提示(id,"等待另一边玩家入场！")
      return
    else
    战斗准备类:创建玩家战斗(天梯数据.战斗池[k].主, 200009,天梯数据.战斗池[k].客)
    table.remove(天梯数据.战斗池,k)
    end
  end

end

function 系统处理类:进入天梯竞技战斗3(id)
  for k,v in pairs(天梯数据.战斗池) do
    if 玩家数据[天梯数据.战斗池[k].主].队伍 == 0 then
      常规提示(天梯数据.战斗池[k].主,"#R[匹配取消]#Y三人模式必须组队！请重新匹配！")
      常规提示(天梯数据.战斗池[k].客,"#R[匹配取消]#Y对方匹配条件不符，请重新匹配！")
      天梯数据.玩家信息[天梯数据.战斗池[k].主].匹配中=false
      天梯数据.玩家信息[天梯数据.战斗池[k].客].匹配中=false
      table.remove(天梯数据.战斗池,k)
      return
    elseif #队伍数据[玩家数据[天梯数据.战斗池[k].主].队伍].成员数据 ~= 3 then
      常规提示(天梯数据.战斗池[k].主,"#R[匹配取消]#Y三人模式必须队员为3人！请重新匹配！")
      常规提示(天梯数据.战斗池[k].客,"#R[匹配取消]#Y对方匹配条件不符，请重新匹配！")
      天梯数据.玩家信息[天梯数据.战斗池[k].主].匹配中=false
      天梯数据.玩家信息[天梯数据.战斗池[k].客].匹配中=false
      table.remove(天梯数据.战斗池,k)
      return
    end--主队判断结束
    if 玩家数据[天梯数据.战斗池[k].客].队伍 == 0 then
      常规提示(天梯数据.战斗池[k].客,"#R[匹配取消]#Y三人模式必须组队！请重新匹配！")
      常规提示(天梯数据.战斗池[k].主,"#R[匹配取消]#Y对方匹配条件不符，请重新匹配！")
      天梯数据.玩家信息[天梯数据.战斗池[k].主].匹配中=false
      天梯数据.玩家信息[天梯数据.战斗池[k].客].匹配中=false
      table.remove(天梯数据.战斗池,k)
      return
    elseif #队伍数据[玩家数据[天梯数据.战斗池[k].客].队伍].成员数据 ~= 3  then
      常规提示(天梯数据.战斗池[k].客,"#R[匹配取消]#Y三人模式必须队员为3人！请重新匹配！")
      常规提示(天梯数据.战斗池[k].主,"#R[匹配取消]#Y对方匹配条件不符，请重新匹配！")
      天梯数据.玩家信息[天梯数据.战斗池[k].主].匹配中=false
      天梯数据.玩家信息[天梯数据.战斗池[k].客].匹配中=false
      table.remove(天梯数据.战斗池,k)
      return
    end--客队判断结束
    if 天梯数据.战斗池[k]==nil then
      常规提示(id,"等待另一边玩家入场！")
      return
    else
    战斗准备类:创建玩家战斗(天梯数据.战斗池[k].主, 200009,天梯数据.战斗池[k].客)
    table.remove(天梯数据.战斗池,k)
    end
  end
end

function 系统处理类:进入天梯竞技战斗5(id)
  for k,v in pairs(天梯数据.战斗池) do
    if 玩家数据[天梯数据.战斗池[k].主].队伍 == 0 then
      常规提示(天梯数据.战斗池[k].主,"#R[匹配取消]#Y五人模式必须组队！请重新匹配！")
      常规提示(天梯数据.战斗池[k].客,"#R[匹配取消]#Y对方匹配条件不符，请重新匹配！")
      天梯数据.玩家信息[天梯数据.战斗池[k].主].匹配中=false
      天梯数据.玩家信息[天梯数据.战斗池[k].客].匹配中=false
      table.remove(天梯数据.战斗池,k)
      return
    elseif #队伍数据[玩家数据[天梯数据.战斗池[k].主].队伍].成员数据 ~= 5 then
      常规提示(天梯数据.战斗池[k].主,"#R[匹配取消]#Y五人模式必须队员为5人！请重新匹配！")
      常规提示(天梯数据.战斗池[k].客,"#R[匹配取消]#Y对方匹配条件不符，请重新匹配！")
      天梯数据.玩家信息[天梯数据.战斗池[k].主].匹配中=false
      天梯数据.玩家信息[天梯数据.战斗池[k].客].匹配中=false
      table.remove(天梯数据.战斗池,k)
      return
    end--主队判断结束
    if 玩家数据[天梯数据.战斗池[k].客].队伍 == 0 then
      常规提示(天梯数据.战斗池[k].客,"#R[匹配取消]#Y五人模式必须组队！请重新匹配！")
      常规提示(天梯数据.战斗池[k].主,"#R[匹配取消]#Y对方匹配条件不符，请重新匹配！")
      天梯数据.玩家信息[天梯数据.战斗池[k].主].匹配中=false
      天梯数据.玩家信息[天梯数据.战斗池[k].客].匹配中=false
      table.remove(天梯数据.战斗池,k)
      return
    elseif #队伍数据[玩家数据[天梯数据.战斗池[k].客].队伍].成员数据 ~= 5  then
      常规提示(天梯数据.战斗池[k].客,"#R[匹配取消]#Y五人模式必须队员为5人！请重新匹配！")
      常规提示(天梯数据.战斗池[k].主,"#R[匹配取消]#Y对方匹配条件不符，请重新匹配！")
      天梯数据.玩家信息[天梯数据.战斗池[k].主].匹配中=false
      天梯数据.玩家信息[天梯数据.战斗池[k].客].匹配中=false
      table.remove(天梯数据.战斗池,k)
      return
    end--客队判断结束
    if 天梯数据.战斗池[k]==nil then
      常规提示(id,"等待另一边玩家入场！")
      return
    else
    战斗准备类:创建玩家战斗(天梯数据.战斗池[k].主, 200009,天梯数据.战斗池[k].客)
    table.remove(天梯数据.战斗池,k)
    end
  end
end

--======↑======2020-10-18 23:17===天梯系统====================


--============元神突破开始====================

-- function 系统处理类:元神突破(id)
--   local 一阶=玩家数据[id].角色.数据.元神突破一阶
--   local 二阶=玩家数据[id].角色.数据.元神突破二阶
--   local 三阶=玩家数据[id].角色.数据.元神突破三阶
--   local 四阶=玩家数据[id].角色.数据.元神突破四阶
--   local 五阶=玩家数据[id].角色.数据.元神突破五阶
--   local 数据=玩家数据[id].角色.数据

--   if not 一阶 then
--     local 临时数据={}
--     临时数据.模型="男人_巫医"
--     临时数据.名称=玩家数据[id].角色.数据.名称
--     临时数据.对话="是否确定将元神突破等级提升至一阶?(消耗10亿经验或200万仙玉)"
--     临时数据.选项={"确认消耗10亿经验","确认消耗200万仙玉","我还没想好呢"}
--     发送数据(id,1501,临时数据)
--     常规提示(id,数据.模型)
--     常规提示(id,数据.名称)
--     return
--     elseif 一阶 and not 二阶 then

--     local 临时数据={}
--     临时数据.模型="男人_巫医"
--     临时数据.名称=玩家数据[id].角色.数据.名称
--     临时数据.对话="是否确定将元神突破等级提升至一阶?(消耗10亿经验或200万仙玉)"
--     临时数据.选项={"确认消耗10亿经验","确认消耗200万仙玉"}
--     发送数据(id,1501,临时数据)
--     常规提示(id,数据.模型)
--     常规提示(id,数据.名称)
--     return
--   end
-- end


--============元神突破结束====================



function 系统处理类:显示(x,y) end
return 系统处理类